Heal Engine 1.0.4

[KitsuneTailsPrower]

Going to download this if it gets approved

 

[Marchombre]

Version 1.0.1 :

• Changed condition for ZeroHealEvent & AfterHealEvent to use struct members and not globals variables.
• Added the possibility to fire more than one PreHealEvent with new parameter MAX_PREHEAL_EVENTS if you need more steps to separate different modifiers.

 

[Marchombre]

I thought it would be nice to get a bit more control on the HealDetection system

---

Version 1.0.2

Added a bunch of constant that will allow to ignore some types of units:
IGNORE_LOCUST - Default: true - Ignore units with locust ability (ex: dummies)
IGNORE_STRUCTURE - Default: false - Ignore structures (unit classification must be consistent)
IGNORE_MECHANICAL - Default: false - Ignore mechanical (unit classification must be consistent)
IGNORE_SUMMONED - Default: false - Ignore summoned units (unit classification must be consistent)
IGNORE_HERO - Default: false - Ignore heroes
IGNORE_NON_HERO - Default: false - Ignore every units except heroes

 

[SoyMante]

I'm curious to see how you develop it, it will have many great uses if perfected.

 

[Marchombre]

I'm curious to see how you develop it, it will have many great uses if perfected.

Feel free to make suggestions

I have currently added everything I said "Damn, I wish I could do that" for.
I'm pretty sure there are others uses I didn't even think of yet, and I'll do my best to add them if someone point them out
Otherwise, I'll wait until a new need rise in the map I'm currently maintaining

 

[Daffa]

How does the MaxPreHeal event works in detail? I think there can be room for spells that 'interrupt' any healing and cancel their effect completely, or spells that only selectively negate certain heals

 

[Marchombre]

How does the MaxPreHeal event works in detail?

MAX_PREHEAL_EVENTS is a config constant, not an event in itself.

It dictates how many PreHealEvents are fired before applying the heal.

For example, with MAX_PREHEAL_EVENTS = 1, you will have only PreHealEvent = 1.00
With MAX_PREHEAL_EVENTS = 5, you'll get PreHealEvent =1.00, PreHealEvent = 2.00, PreHealEvent = 3.00, PreHealEvent = 4.00 & PreHealEvent =5.00

I think there can be room for spells that 'interrupt' any healing and cancel their effect completely,

It is possible to completely negate a heal.
For example, I'm currently using this system with 4 PreHealEvents:

• PreHealEvent = 1.00 -- flat heal increase
• PreHealEvent = 2.00 -- % heal increase
• PreHealEvent = 3.00 -- % heal reduction
• PreHealEvent = 4.00 -- flat heal reduction

Having healing reduction after any heal increase will allow you to give a 100% heal reduction and negate the heal entirely.

or spells that only selectively negate certain heals

This part is quite limited for now. You can only do a threshold (like every heal < 100 will be negated), or check if the unit is self healing with IsSelfHeal.

---

Feel free to correct me I misunderstood you, and suggest improvements

 

[Antares]

Healing through code is so much better than these dirty hacks required to detect native heals, so that is a welcome addition to the Heal Detection system. Since it is possible to use the system without using any native heals, you should make an option to disable that feature (and remove the unit indexer requirement if possible).

I think overheal is poorly handled. Instead of having a separate event, I think there should be just the heal event which sets the variables Raw Heal, Effective Heal, and Overheal. In any case, even if you keep the separate overheal event, an effective heal variable should exist.

I didn't find any problems with the code and all of the features seem to be working without problems.

Approved

 

[Marchombre]

Thanks for the approval

Healing through code is so much better than these dirty hacks required to detect native heals, so that is a welcome addition to the Heal Detection system. Since it is possible to use the system without using any native heals, you should make an option to disable that feature (and remove the unit indexer requirement if possible).

That's a good idea. I guess I could just put a condition in the onInit of HealDetection struct and avoid creating the triggers/timers for native heals.
This should be enough, as long I clearly state that unit indexer is required if config allows native heals detection.

I think overheal is poorly handled. Instead of having a separate event, I think there should be just the heal event which sets the variables Raw Heal, Effective Heal, and Overheal. In any case, even if you keep the separate overheal event, an effective heal variable should exist.

OverHealEvent was, in my opinion, like ZeroHealEvent. An event for convenience and trigger clarity, more that mandatory thing to have. Way easier - in my mind at least - to code and read "Check OverHealEvent = 1.00" than "Check if AfterHealEvent = 1.00 and OverHealAmount > 0.00", especially when using GUI.

However, I agree that EffectiveHeal is missing and will add that in next version

I didn't find any problems with the code and all of the features seem to be working without problems.

Well, as a matter of fact, I did find one problem myself
If user catch PreHealEvent and apply heal reduction superior to the heal amount, the system would damage the unit and would still trigger events.

I'll probably add a config option to decide if negative healing should damage the target or act as a 0 heal. And will use a proper damaging function so damage engines can catch it.
Might add a NegativeHealEvent too ? Not sure of that yet.

 

[Aldeia]

Would you add LUA version as well? (might come in handy for people that make the map on LUA - even for GUI users)

 

[Marchombre]

Would you add LUA version as well? (might come in handy for people that make the map on LUA - even for GUI users)

I haven't looked into lua yet, so not planned right now.
I might try in the future, but will not be my priority. And I'll probably wait to have a version stable enough so I don't have to duplicate every single change

 

[Antares]

Variable events do not work in Lua, so the entire system would have to be rewritten.

 

[Marchombre]

Version 1.0.3

---

New/Changed config options:
USE_HEAL_DETECTION - Default: true - Enable/disable HealDetection triggers. If set to true, make sure to have Unit Indexer requirement

IS_NATIVE_HEALING_SELF - Default: false - Should native healing be considered as self healing ?
IS_NATIVE_REGEN_SELF - Default: true - Should native HP regen be considered as self healing ?

ALLOW_NEGATIVE_HEALING - Default: false - If true, negative healing after PreHealEvents will do damage. Else, heal won't go under 0.
NEGATIVE_HEAL_THRESHOLD - Default: -1.00 - Used only if ALLOW_NEGATIVE_HEALING = true. Threshold for firing NegativeHealEvent.

New Event:
Game - NegativeHealEvent Becomes Equal to 1.00 - Triggered heal only, needs ALLOW_NEGATIVE_HEALING set to true in config - This event runs when heal become negative during PreHealEvent, thus dealing damage.

New/Changed variables:
HealBaseAmount - Initial healing amount, before any modification. This variable should be treated as readonly.
HealPrvAmount - Healing amount at the start of this step. This variable should be treated as readonly.

EffectiveHealAmount - How much healing was done. Access this in AfterHealEvent and/or in OverHealEvent.

---

 

[DoomBlade]

A very useful system seems to work without causing any issues.

 

[Nikac95]

Hello @Marchombre , excellent system!

I ran into some things, and noticed that, for example: if a Hero has the Attribute Bonus ability, when learned, it will show the HP gained from strength as a heal.

Is there a way to exclude that?

 

[Marchombre]

Hello @Marchombre , excellent system!

I ran into some things, and noticed that, for example: if a Hero has the Attribute Bonus ability, when learned, it will show the HP gained from strength as a heal.

Is there a way to exclude that?

Gaining Max HPs is indeed detected as heal. This is because when gaining Max HPs, you are also gaining current HPs, which is what is tracked by the detection part of the system.


I'm not sure how to fix that, and I'm currently working on other things, so it might take a while for me to update and fix this issue.

Best way to use this system is still to go full triggered healing and thus not needing the detection that's causing this issue (by setting USE_HEAL_DETECTION = false)

 

[Nikac95]

Gaining Max HPs is indeed detected as heal. This is because when gaining Max HPs, you are also gaining current HPs, which is what is tracked by the detection part of the system.


I'm not sure how to fix that, and I'm currently working on other things, so it might take a while for me to update and fix this issue.

Best way to use this system is still to go full triggered healing and thus not needing the detection that's causing this issue (by setting USE_HEAL_DETECTION = false)

Alright

Thank you for the feedback and for the tip.

 

[Marchombre]

Can't believe I haven't spotted this earlier.

Version 1.0.4

---

• Fix a bug Effective heal computing. Effective heal was giving negative value due to switching variable in formula.
• Overheal event is now properly working. Due to previous bug and overheal amount being calculated from effective healing, overheal was firing way to often.

 

[Kotol]

What about Heal and Mana Restoration Engine 2.0.0 ? Just duplicate the Heal Engine codes and change variables "Heal" with "Mana", Life of Unit with Mana of Unit and Strength with Intelligence. With this way, we can detect native Mana Restoration and Mana Regeneration addition of Heal and Health Restoration. @Marchombre @Bribe.

 

[Marchombre]

What about Heal and Mana Restoration Engine 2.0.0 ? Just duplicate the Heal Engine codes and change variables "Heal" with "Mana", Life of Unit with Mana of Unit and Strength with Intelligence. With this way, we can detect native Mana Restoration and Mana Regeneration addition of Heal and Health Restoration. @Marchombre @Bribe.

To be honest, I thought about doing mana engine, but didn't need it as much and things are never as easy as duplicating and changing 1 variable
I might do it later this summer though.

 

[Wing-Span]

I tried to find tranquility. I succeeded only with the help of "AfterHealingEvent".

Further installation of "HealAmount" works, judging by the text report, but the heal does not increase. Alas, this is all my powers.

 

[Marchombre]

I tried to find tranquility. I succeeded only with the help of "AfterHealingEvent".

Further installation of "HealAmount" works, judging by the text report, but the heal does not increase. Alas, this is all my powers.

If you're using the native tranquility, that is the expected behavior.
Native heals can only be detected after their effects have been applied, and thus can only trigger the AfterHealingEvent.

If you wish to have a tranquility working with healing boost on PreHealEvent, you'll have to trigger it.

 

[Wing-Span]

If you're using the native tranquility, that is the expected behavior.
Native heals can only be detected after their effects have been applied, and thus can only trigger the AfterHealingEvent.

If you wish to have a tranquility working with healing boost on PreHealEvent, you'll have to trigger it.

I called it by setting it to one, but the text report did not appear, from which I concluded that tracking was not happening =(

 

[Marchombre]

I called it by setting it to one, but the text report did not appear, from which I concluded that tracking was not happening =(

Could you share a test map please, that would be easier to see what's going on

 

[Wing-Span]

Could you share a test map please, that would be easier to see what's going on

It just doesn't work...
I simplified the trigger to the maximum to make sure it would work, but no.

 

[Marchombre]

It just doesn't work...
I simplified the trigger to the maximum to make sure it would work, but no.

So, like I was saying here:

If you're using the native tranquility, that is the expected behavior.
Native heals can only be detected after their effects have been applied, and thus can only trigger the AfterHealingEvent.

If you wish to have a tranquility working with healing boost on PreHealEvent, you'll have to trigger it.

Native healing (ie pre existing abilities) can only use the AfterHealingEvent.


If you want to use other events, you need to trigger the healing.
You should look the "Healing ability" folder that gives 2 examples of triggered ability that can heal and use PreHealingEvent and use that to implement a tranquility spell.

 

[Regno]

Do I need the GUI Unit Indexer if I only want the vJass engine? I don't use GUI

 

[Marchombre]

Do I need the GUI Unit Indexer if I only want the vJass engine? I don't use GUI

You need the GUI Unit Indexer if and only if you need to detect native healing / hp regen (config: USE_HEAL_DETECTION = true)

If you want to use this engine only to make triggered healing and event from triggered healing only, then you don't need it.

 

[Kotol]

To be honest, I thought about doing mana engine, but didn't need it as much and things are never as easy as duplicating and changing 1 variable
I might do it later this summer though.

I've finished making the Mana Engine which I mentioned earlier. I can share it with you if you'd like. @Marchombre

Mana Engine Code

/*
    vJass ManaEngine 1.0.0
    by Kotol

    Requirement if using ManaRestorationDetection: GUI Unit Indexer 1.4.0.0 (by Bribe)
*/

/*
    ==================
    ==== Jass API ====
    ==================

    // This struct is used for native mana restoration and mana regeneration detection
    struct ManaDetection
        // Add unit (by its index) to the detection system
        static method AddUnit takes integer unitId returns nothing

        // Remove unit (by its index) from the detection system
        static method SystemRemoveUnit takes integer unitId returns nothing

        // Used for Optional trigger
        // Force a check on target unit. Used before applying damage.
        static method Adjust takes unit target returns nothing

        // Used for Optional trigger
        // Adjust values after taking damage, or some events might not trigger due to MP diff
        static method AdjustAfterDamage takes unit target, real dmg returns nothing

        // Adjust values after receiving a triggered mana, to avoid triggering the mana restoration event a second time by detection
        static method AdjustAfterMana takes unit u, real mana returns nothing

    // This struct is used for triggered mana restoration and complete Mana Events
    struct Mana
        // User Entry Point. Takes mana source, target and amount
        // If an other mana is currently running, postpon new one to avoid conflicts
        static method ManaUnit takes unit source, unit target, real amount

*/
library ManaEngine
    globals
        /*
            Variables used for detecting war3 native mana restoration and mana regeneration
        */
        private constant boolean USE_MANA_DETECTION         = true      // Enable/disable ManaDetection triggers. If set to true, make sure to have Unit Indexer requirement

        private constant real MANA_THRESHOLD                = 5.00
        private constant real MANA_CHECK_INTERVAL           = 0.05

        private constant real MANA_REGEN_INTELLIGENCE_VALUE = 0.05
        private constant real MANA_REGEN_THRESHOLD          = 5.00
        private constant real MANA_REGEN_EVENT_INTERVAL     = 1.00

        private constant boolean IS_NATIVE_MANA_SELF        = false     // True: native mana restoration will be considered self mana restoration. False: considered from an unknown source
        private constant boolean IS_NATIVE_MANA_REGEN_SELF  = true      // True: mana regen will be considered self mana restoration. False: considered from an unknown source

        // Booleans to control control what type of units should be ignored by the ManaDetection system.
        private constant boolean IGNORE_LOCUST              = true      // Units with locust ability (ex: dummies)
        private constant boolean IGNORE_STRUCTURE           = false     // Structures (unit classification must be consistent)
        private constant boolean IGNORE_MECHANICAL          = false     // Mechanical (unit classification must be consistent)
        private constant boolean IGNORE_SUMMONED            = false     // Summoned units (unit classification must be consistent)
        private constant boolean IGNORE_HERO                = false     // Heroes
        private constant boolean IGNORE_NON_HERO            = false     // Every units except heroes

        /*
            Config for Events
        */
        private constant real ZEROMANA_THRESHOLD            = 1.00      // Mana restore under this value will fire ZeroManaEvent
        private constant real OVERMANA_THRESHOLD            = 1.00      // How much overmana is needed to fire OverManaEvent
        private constant real MAX_PREMANA_EVENTS            = 4.00      // PreManaEvent will fire this many time. Useful if you want to make sure modifiers are applied if the right order (% then flat for example).
      
        private constant boolean ALLOW_NEGATIVE_MANA        = false     // If true, negative mana restoration after PreManaEvents will do damage. Else, mana restore won't go under 0.
        private constant real NEGATIVE_MANA_THRESHOLD       = -1.00     // Used if ALLOW_NEGATIVE_MANA = true. Threshold for firing NegativeManaEvent.
    endglobals

    // GUI vars for those who really don't want to call custom script
    // These are set before running a trigger calling this engine
    /*
        unit                udg_NextManaSource
        unit                udg_NextManaTarget
        real                udg_NextManaAmount
    */

    // GUI Vars to catch events
    /*

        // Variables you can access to get infos on current mana
        unit                udg_ManaSource
        unit                udg_ManaTarget

        real                udg_ManaAmount              // Current mana amount.
        real                udg_ManaBaseAmount          // Mana amount before any event was fired.
        real                udg_ManaPrvAmount           // Mana amount at the start of this event.

        real                udg_EffectiveManaAmount     // How much MPs was actually mana restored.
        real                udg_OverManaAmount          // How much mana is left after getting the unit to full MP.
        boolean             udg_IsSelfMana

        // Events variables
        real                udg_PreManaEvent            // Can be 0.00 or X.00, with 1 <= X <= MAX_PREMANA_EVENTS
        real                udg_AfterManaEvent          // Can be 0.00 or 1.00 or 0.50
        real                udg_ZeroManaEvent           // Can be 0.00 or 1.00
        real                udg_OverManaEvent           // Can be 0.00 or 1.00
        real                udg_NegativeManaEvent       // Can be 0.00 or 1.00

    */
  
    struct ManaDetection
        private static trigger checkLoopTrigger
        private static trigger addUnitTrigger
        private static trigger removeUnitTrigger

        private static boolean array isInSystem
        private static integer array indices
        private static integer array indexRef
      
        private static real array lastMana
        private static real array manaregen

        private static real array manaregenBuildUp
        private static real array manaregenTimeLeft
      
        private static integer count        = 0
        private static integer unitIndex    = 0

        private static timer manaTimer
      
      
        static method AddUnit takes integer unitId returns nothing
            // if Unit is already in system or unit match one ignore config, then do nothing
            if isInSystem[unitId] /*
                */ or (GetUnitAbilityLevel(udg_UDexUnits[unitId], 'Aloc') > 0 and IGNORE_LOCUST)/*
                */ or (IsUnitType(udg_UDexUnits[unitId], UNIT_TYPE_MECHANICAL) and IGNORE_MECHANICAL) /*
                */ or (IsUnitType(udg_UDexUnits[unitId], UNIT_TYPE_STRUCTURE) and IGNORE_STRUCTURE) /*
                */ or (IsUnitType(udg_UDexUnits[unitId], UNIT_TYPE_SUMMONED) and IGNORE_SUMMONED) /*
                */ or (IsUnitType(udg_UDexUnits[unitId], UNIT_TYPE_HERO) and IGNORE_HERO) /*
                */ or (not IsUnitType(udg_UDexUnits[unitId], UNIT_TYPE_HERO) and IGNORE_NON_HERO) /*
                */ then
                return
            endif

            set isInSystem[unitId]      = true
            set indices[count]          = unitId
            set indexRef[unitId]        = count
            set lastMana[unitId]        = GetUnitState(udg_UDexUnits[unitId], UNIT_STATE_MANA)
            set manaregenTimeLeft[unitId]   = MANA_REGEN_EVENT_INTERVAL
          
            set count = count +1

            // If first unit added, turn on checkloop
            if count == 1 then
                call EnableTrigger(checkLoopTrigger)
            endif

        endmethod

        static method SystemRemoveUnit takes integer unitId returns nothing
            // If unit not in system, can't remove them, so just returns
            if not isInSystem[unitId] then
                return
            endif

            set isInSystem[unitId]          = false
            set count = count -1
            set indices[indexRef[unitId]]   = indices[count]
            set indexRef[indices[count]]    = indexRef[unitId]

            // If last unit in system, turn off checkloop
            if count == 0 then
                call DisableTrigger(checkLoopTrigger)
            endif

        endmethod

        private static method CheckLoop takes nothing returns nothing
            local integer max = count -1
            local integer unitIndex = 0

            local unit target
            local real unitMP
            local real diff
            local real mana
          
            loop
                exitwhen unitIndex > max
              
                set unitIndex = indices[unitIndex]

                set target              = udg_UDexUnits[unitIndex]
                set unitMP              = GetUnitState(target, UNIT_STATE_MANA)
                set diff                = unitMP - lastMana[unitIndex]
                set lastMana[unitIndex] = unitMP

                set mana                = diff - RMaxBJ(0.00, manaregen[unitIndex])

                if mana > MANA_THRESHOLD then
                    // Set Up variables
                    set udg_ManaAmount = mana
                    set udg_ManaTarget = target

                    if IS_NATIVE_MANA_SELF then
                        set udg_ManaSource = target
                    else
                        set udg_ManaSource = null   // Can't know the source of a native mana restoration sadly
                    endif
                  
                    set udg_IsSelfMana = IS_NATIVE_MANA_SELF

                    // Fire AfterManaEvent
                    set udg_AfterManaEvent  = 0.00
                    set udg_AfterManaEvent  = 1.00
                    set udg_AfterManaEvent  = 0.00
                else
                    // Check ManaRegen
                    set manaregen[unitIndex] = (manaregen[unitIndex] + diff) * 0.5

                    set manaregenBuildUp[unitIndex]     = manaregenBuildUp[unitIndex] + diff
                    set manaregenTimeLeft[unitIndex]    = manaregenTimeLeft[unitIndex] - MANA_CHECK_INTERVAL

                    if manaregenTimeLeft[unitIndex] <= 0.00 then
                        // reset clock
                        set manaregenTimeLeft[unitIndex] = MANA_REGEN_EVENT_INTERVAL

                        set mana = manaregenBuildUp[unitIndex]
                        set manaregenBuildUp[unitIndex] = 0.00
                      
                        set diff = mana

                        // Ignore manaregen from hero stats
                        if IsUnitType(target, UNIT_TYPE_HERO) then
                            set diff = diff - MANA_REGEN_INTELLIGENCE_VALUE * I2R(GetHeroInt(target, true))
                        endif

                        // Fire ManaRegen Event (AfterManaEvent = 0.5)
                        if diff > MANA_REGEN_THRESHOLD then
                             // Set Up variables
                            set udg_ManaAmount = mana
                            set udg_ManaTarget = target

                            if IS_NATIVE_MANA_REGEN_SELF then
                                set udg_ManaSource = target
                            else
                                set udg_ManaSource = null   // Can't know the source of a native mana restoration sadly
                            endif
                          
                            set udg_IsSelfMana = IS_NATIVE_MANA_REGEN_SELF

                            // Fire AfterManaEvent
                            set udg_AfterManaEvent  = 0.00
                            set udg_AfterManaEvent  = 0.50
                            set udg_AfterManaEvent  = 0.00
                        endif
                    endif
                endif

                set unitIndex = indexRef[unitIndex]
                set unitIndex = unitIndex +1
            endloop
        endmethod

        // Check unit new mana and fire AfterManaEvent if needed
        static method Adjust takes unit target returns nothing
            local integer index     = GetUnitUserData(target)
            local real u_mp         = GetUnitState(target, UNIT_STATE_MANA)
          
            local real mana = u_mp - lastMana[index] - manaregen[index] * TimerGetElapsed(manaTimer) / MANA_CHECK_INTERVAL

            if mana > MANA_THRESHOLD then
                set lastMana[index] = lastMana[index] + mana
              
                // Set Up variables
                set udg_ManaAmount = mana
                set udg_ManaTarget = target

                if IS_NATIVE_MANA_SELF then
                    set udg_ManaSource = target
                else
                    set udg_ManaSource = null   // Can't know the source of a native mana restoration sadly
                endif
              
                set udg_IsSelfMana = IS_NATIVE_MANA_SELF

                // Fire AfterManaEvent
                set udg_AfterManaEvent  = 0.00
                set udg_AfterManaEvent  = 1.00
                set udg_AfterManaEvent  = 0.00
            endif
        endmethod

        // Adjust values when unit takes damage, or mana might not be detected
        static method AdjustAfterDamage takes unit target, real dmg returns nothing
            local integer index     = GetUnitUserData(target)
            local real u_mp         = GetUnitState(target, UNIT_STATE_MANA)

            if dmg > 0 then
                set lastMana[index] = u_mp - manaregen[index] * TimerGetElapsed(manaTimer) / MANA_CHECK_INTERVAL
            else
                call Adjust(target)
            endif
        endmethod

        // Adjust after mana, avoiding a double event for one mana
        static method AdjustAfterMana takes unit u, real mana returns nothing
            local integer index = GetUnitUserData(u)
            set lastMana[index] = lastMana[index] + mana
        endmethod

        private static method ActionAddUnit takes nothing returns nothing
            call AddUnit(udg_UDex)
        endmethod

        private static method ActionRemoveUnit takes nothing returns nothing
            call SystemRemoveUnit(udg_UDex)
        endmethod

        private static method onInit takes nothing returns nothing
            if USE_MANA_DETECTION then
                set manaTimer           = CreateTimer()
                set checkLoopTrigger    = CreateTrigger()
                set addUnitTrigger      = CreateTrigger()
                set removeUnitTrigger   = CreateTrigger()

                call StartTimerBJ(manaTimer, true, MANA_CHECK_INTERVAL)
              
                call TriggerRegisterTimerExpireEvent(checkLoopTrigger, manaTimer)
                call TriggerAddAction(checkLoopTrigger, function ManaDetection.CheckLoop)

                call TriggerRegisterVariableEvent(addUnitTrigger, "udg_UnitIndexEvent", EQUAL, 1.00)
                call TriggerRegisterVariableEvent(addUnitTrigger, "udg_DeathEvent", EQUAL, 2.00)
                call TriggerAddAction(addUnitTrigger, function ManaDetection.ActionAddUnit)

                call TriggerRegisterVariableEvent(removeUnitTrigger, "udg_UnitIndexEvent", EQUAL, 2.00)
                call TriggerRegisterVariableEvent(removeUnitTrigger, "udg_DeathEvent", EQUAL, 0.50)
                call TriggerRegisterVariableEvent(removeUnitTrigger, "udg_DeathEvent", EQUAL, 1.00)
                call TriggerRegisterVariableEvent(removeUnitTrigger, "udg_DeathEvent", EQUAL, 3.00)
                call TriggerAddAction(removeUnitTrigger, function ManaDetection.ActionRemoveUnit)
            endif
        endmethod
    endstruct

    struct Mana

        /*
            Variables used in mana restoration
        */
        private unit manaSource
        private unit manaTarget

        private real manaBaseAmt
        private real manaPrevAmt
        private real manaAmount
      
        private real effectiveManaAmt
        private real overManaAmount

        private boolean isSelfMana
      
        /*
            Variables used for listing
        */
        private Mana next

        private static Mana first
        private static Mana last


        private static method create takes unit source, unit target, real amount returns Mana
            local Mana this = Mana.allocate()

            set this.manaSource         = source
            set this.manaTarget         = target
            set this.manaAmount         = amount
            set this.manaBaseAmt        = amount
            set this.manaPrevAmt        = amount

            set this.isSelfMana         = (source == target)
            set this.overManaAmount     = 0
            set this.effectiveManaAmt   = 0

            set this.next = 0
          
            return this
        endmethod

        private method destroy takes nothing returns nothing
            call this.deallocate()
        endmethod

        private static method onInit takes nothing returns nothing
            set first = 0
            set last = 0
        endmethod

        /*
            Entry point for user.
        */
        static method ManaUnit takes unit source, unit target, real amount returns nothing
            local Mana h = Mana.create(source, target, amount)

            if first == 0 then
                set first = h
                set last = h
                call Mana.Run()
            else
                set last.next = h
                set last = last.next
            endif

        endmethod

        // Put this instance members into GUI variables
        private method setEventVariables takes nothing returns nothing
            set udg_ManaSource              = this.manaSource
            set udg_ManaTarget              = this.manaTarget
          
            set udg_ManaAmount              = this.manaAmount
            set udg_ManaBaseAmount          = this.manaBaseAmt
            set udg_ManaPrvAmount           = this.manaPrevAmt
          
            set udg_EffectiveManaAmount     = this.effectiveManaAmt
            set udg_OverManaAmount          = this.overManaAmount

            set udg_IsSelfMana              = this.isSelfMana
        endmethod

        // Updates this instance members with GUI vars that might have been updated
        private method getEventVariables takes nothing returns nothing
            set this.manaSource     = udg_ManaSource
            set this.manaTarget     = udg_ManaTarget
            set this.manaAmount     = udg_ManaAmount
            set this.manaPrevAmt    = udg_ManaAmount    // Stores this step result for reference in next step if needed.

            set this.isSelfMana     = (this.manaSource == this.manaTarget)
        endmethod

        // Reset Variables to a neutral state
        private static method resetEventVariables takes nothing returns nothing
            set udg_ManaSource              = null
            set udg_ManaTarget              = null

            set udg_ManaBaseAmount          = 0.00
            set udg_ManaPrvAmount           = 0.00
            set udg_ManaAmount              = 0.00

            set udg_EffectiveManaAmount     = 0.00
            set udg_OverManaAmount          = 0.00

            set udg_IsSelfMana              = false
        endmethod

        /*
            Function where the hmana restoration and Events are done.
            Mana restoration are dealt one at the time. Mana restoration created during Events will be postponed.
        */
        private static method Run takes nothing returns nothing
            local Mana h
            local integer u_custom
            local real u_current_mp
            local real u_max_mp
            local real u_missing_mp
            local real new_missing_mp
            local real i = 1.00

            loop
                exitwhen first == null
              
                set h = first
              
                // Using not == instead of !=; the idea is to eliminate floating point bugs when two numbers are very close to 0,
                // because JASS uses a less-strict comparison for checking if a number is equal than when it is unequal.
                if not (h.manaAmount == 0.00) then

                    loop
                        exitwhen i > MAX_PREMANA_EVENTS
                        // Set GUI vars
                        call h.setEventVariables()

                        // Fire PreManaEvent
                        set udg_PreManaEvent    = 0.00
                        set udg_PreManaEvent    = i
                        set udg_PreManaEvent    = 0.00

                        // Update fields in case event was caught and variables changed.
                        call h.getEventVariables()

                        set i = i +1.00
                    endloop

                    if not ALLOW_NEGATIVE_MANA and h.manaAmount < 0.00 then
                        set h.manaAmount = 0.00
                    endif                      
                  
                    // Get target infos
                    set u_custom            = GetUnitUserData(h.manaTarget)
                    set u_max_mp            = GetUnitState(h.manaTarget, UNIT_STATE_MAX_MANA)
                    set u_current_mp         = GetUnitState(h.manaTarget, UNIT_STATE_MANA)
                    set u_missing_mp        = u_max_mp - u_current_mp
                  
                    if h.manaAmount > 0 then
                        // Mana Restoration itself.
                        call SetUnitState(h.manaTarget, UNIT_STATE_MANA, u_current_mp + h.manaAmount)
                      
                        // Getting new missing mp
                        set new_missing_mp = GetUnitState(h.manaTarget, UNIT_STATE_MAX_MANA) - GetUnitState(h.manaTarget, UNIT_STATE_MANA)

                        // Computing effective mana restoration and possible overmana restoration
                        set h.effectiveManaAmt = u_missing_mp - new_missing_mp
                        set h.overManaAmount = h.manaAmount - h.effectiveManaAmt
                    else
                        // Use Damage function to be compatible with damage engines
                        call UnitDamageTargetBJ(h.manaSource, h.manaTarget, h.manaAmount, ATTACK_TYPE_MAGIC, DAMAGE_TYPE_MAGIC)
                        set h.effectiveManaAmt = h.manaAmount
                    endif
                  
                    // Fire OverManaEvent
                    if h.overManaAmount > OVERMANA_THRESHOLD then
                        // Set GUI vars
                        call h.setEventVariables()

                        set udg_OverManaEvent   = 0.00
                        set udg_OverManaEvent   = 1.00
                        set udg_OverManaEvent   = 0.00
                    endif

                    // Fire AfterManaEvent if enough mana restoration was done, else ZeroManaEvent
                    if h.effectiveManaAmt > ZEROMANA_THRESHOLD or (h.overManaAmount > 0.00) then
                        // Update ManaDetection system, avoiding the event triggering twice for this mana restoration
                        call ManaDetection.AdjustAfterMana(h.manaTarget, h.manaAmount)

                        // Set GUI vars
                        call h.setEventVariables()

                        set udg_AfterManaEvent  = 0.00
                        set udg_AfterManaEvent  = 1.00
                        set udg_AfterManaEvent  = 0.00
                    elseif h.effectiveManaAmt < NEGATIVE_MANA_THRESHOLD then
                        // Set GUI vars
                        call h.setEventVariables()

                        set udg_NegativeManaEvent   = 0.00
                        set udg_NegativeManaEvent   = 1.00
                        set udg_NegativeManaEvent   = 0.00
                    else
                        // Set GUI vars
                        call h.setEventVariables()

                        set udg_ZeroManaEvent   = 0.00
                        set udg_ZeroManaEvent   = 1.00
                        set udg_ZeroManaEvent   = 0.00
                    endif

                endif

                // Resets variables
                call resetEventVariables()

                // Set the next mana that will be run
                set first = h.next
              
                // Free resources
                call h.destroy()
            endloop

        endmethod
    endstruct

endlibrary

 

[Kotol]

I've finished making the Mana Engine which I mentioned earlier. I can share it with you if you'd like. @Marchombre

Mana Engine Code

/*
    vJass ManaEngine 1.0.0
    by Kotol

    Requirement if using ManaRestorationDetection: GUI Unit Indexer 1.4.0.0 (by Bribe)
*/

/*
    ==================
    ==== Jass API ====
    ==================

    // This struct is used for native mana restoration and mana regeneration detection
    struct ManaDetection
        // Add unit (by its index) to the detection system
        static method AddUnit takes integer unitId returns nothing

        // Remove unit (by its index) from the detection system
        static method SystemRemoveUnit takes integer unitId returns nothing

        // Used for Optional trigger
        // Force a check on target unit. Used before applying damage.
        static method Adjust takes unit target returns nothing

        // Used for Optional trigger
        // Adjust values after taking damage, or some events might not trigger due to MP diff
        static method AdjustAfterDamage takes unit target, real dmg returns nothing

        // Adjust values after receiving a triggered mana, to avoid triggering the mana restoration event a second time by detection
        static method AdjustAfterMana takes unit u, real mana returns nothing

    // This struct is used for triggered mana restoration and complete Mana Events
    struct Mana
        // User Entry Point. Takes mana source, target and amount
        // If an other mana is currently running, postpon new one to avoid conflicts
        static method ManaUnit takes unit source, unit target, real amount

*/
library ManaEngine
    globals
        /*
            Variables used for detecting war3 native mana restoration and mana regeneration
        */
        private constant boolean USE_MANA_DETECTION         = true      // Enable/disable ManaDetection triggers. If set to true, make sure to have Unit Indexer requirement

        private constant real MANA_THRESHOLD                = 5.00
        private constant real MANA_CHECK_INTERVAL           = 0.05

        private constant real MANA_REGEN_INTELLIGENCE_VALUE = 0.05
        private constant real MANA_REGEN_THRESHOLD          = 5.00
        private constant real MANA_REGEN_EVENT_INTERVAL     = 1.00

        private constant boolean IS_NATIVE_MANA_SELF        = false     // True: native mana restoration will be considered self mana restoration. False: considered from an unknown source
        private constant boolean IS_NATIVE_MANA_REGEN_SELF  = true      // True: mana regen will be considered self mana restoration. False: considered from an unknown source

        // Booleans to control control what type of units should be ignored by the ManaDetection system.
        private constant boolean IGNORE_LOCUST              = true      // Units with locust ability (ex: dummies)
        private constant boolean IGNORE_STRUCTURE           = false     // Structures (unit classification must be consistent)
        private constant boolean IGNORE_MECHANICAL          = false     // Mechanical (unit classification must be consistent)
        private constant boolean IGNORE_SUMMONED            = false     // Summoned units (unit classification must be consistent)
        private constant boolean IGNORE_HERO                = false     // Heroes
        private constant boolean IGNORE_NON_HERO            = false     // Every units except heroes

        /*
            Config for Events
        */
        private constant real ZEROMANA_THRESHOLD            = 1.00      // Mana restore under this value will fire ZeroManaEvent
        private constant real OVERMANA_THRESHOLD            = 1.00      // How much overmana is needed to fire OverManaEvent
        private constant real MAX_PREMANA_EVENTS            = 4.00      // PreManaEvent will fire this many time. Useful if you want to make sure modifiers are applied if the right order (% then flat for example).
     
        private constant boolean ALLOW_NEGATIVE_MANA        = false     // If true, negative mana restoration after PreManaEvents will do damage. Else, mana restore won't go under 0.
        private constant real NEGATIVE_MANA_THRESHOLD       = -1.00     // Used if ALLOW_NEGATIVE_MANA = true. Threshold for firing NegativeManaEvent.
    endglobals

    // GUI vars for those who really don't want to call custom script
    // These are set before running a trigger calling this engine
    /*
        unit                udg_NextManaSource
        unit                udg_NextManaTarget
        real                udg_NextManaAmount
    */

    // GUI Vars to catch events
    /*

        // Variables you can access to get infos on current mana
        unit                udg_ManaSource
        unit                udg_ManaTarget

        real                udg_ManaAmount              // Current mana amount.
        real                udg_ManaBaseAmount          // Mana amount before any event was fired.
        real                udg_ManaPrvAmount           // Mana amount at the start of this event.

        real                udg_EffectiveManaAmount     // How much MPs was actually mana restored.
        real                udg_OverManaAmount          // How much mana is left after getting the unit to full MP.
        boolean             udg_IsSelfMana

        // Events variables
        real                udg_PreManaEvent            // Can be 0.00 or X.00, with 1 <= X <= MAX_PREMANA_EVENTS
        real                udg_AfterManaEvent          // Can be 0.00 or 1.00 or 0.50
        real                udg_ZeroManaEvent           // Can be 0.00 or 1.00
        real                udg_OverManaEvent           // Can be 0.00 or 1.00
        real                udg_NegativeManaEvent       // Can be 0.00 or 1.00

    */
 
    struct ManaDetection
        private static trigger checkLoopTrigger
        private static trigger addUnitTrigger
        private static trigger removeUnitTrigger

        private static boolean array isInSystem
        private static integer array indices
        private static integer array indexRef
     
        private static real array lastMana
        private static real array manaregen

        private static real array manaregenBuildUp
        private static real array manaregenTimeLeft
     
        private static integer count        = 0
        private static integer unitIndex    = 0

        private static timer manaTimer
     
     
        static method AddUnit takes integer unitId returns nothing
            // if Unit is already in system or unit match one ignore config, then do nothing
            if isInSystem[unitId] /*
                */ or (GetUnitAbilityLevel(udg_UDexUnits[unitId], 'Aloc') > 0 and IGNORE_LOCUST)/*
                */ or (IsUnitType(udg_UDexUnits[unitId], UNIT_TYPE_MECHANICAL) and IGNORE_MECHANICAL) /*
                */ or (IsUnitType(udg_UDexUnits[unitId], UNIT_TYPE_STRUCTURE) and IGNORE_STRUCTURE) /*
                */ or (IsUnitType(udg_UDexUnits[unitId], UNIT_TYPE_SUMMONED) and IGNORE_SUMMONED) /*
                */ or (IsUnitType(udg_UDexUnits[unitId], UNIT_TYPE_HERO) and IGNORE_HERO) /*
                */ or (not IsUnitType(udg_UDexUnits[unitId], UNIT_TYPE_HERO) and IGNORE_NON_HERO) /*
                */ then
                return
            endif

            set isInSystem[unitId]      = true
            set indices[count]          = unitId
            set indexRef[unitId]        = count
            set lastMana[unitId]        = GetUnitState(udg_UDexUnits[unitId], UNIT_STATE_MANA)
            set manaregenTimeLeft[unitId]   = MANA_REGEN_EVENT_INTERVAL
         
            set count = count +1

            // If first unit added, turn on checkloop
            if count == 1 then
                call EnableTrigger(checkLoopTrigger)
            endif

        endmethod

        static method SystemRemoveUnit takes integer unitId returns nothing
            // If unit not in system, can't remove them, so just returns
            if not isInSystem[unitId] then
                return
            endif

            set isInSystem[unitId]          = false
            set count = count -1
            set indices[indexRef[unitId]]   = indices[count]
            set indexRef[indices[count]]    = indexRef[unitId]

            // If last unit in system, turn off checkloop
            if count == 0 then
                call DisableTrigger(checkLoopTrigger)
            endif

        endmethod

        private static method CheckLoop takes nothing returns nothing
            local integer max = count -1
            local integer unitIndex = 0

            local unit target
            local real unitMP
            local real diff
            local real mana
         
            loop
                exitwhen unitIndex > max
             
                set unitIndex = indices[unitIndex]

                set target              = udg_UDexUnits[unitIndex]
                set unitMP              = GetUnitState(target, UNIT_STATE_MANA)
                set diff                = unitMP - lastMana[unitIndex]
                set lastMana[unitIndex] = unitMP

                set mana                = diff - RMaxBJ(0.00, manaregen[unitIndex])

                if mana > MANA_THRESHOLD then
                    // Set Up variables
                    set udg_ManaAmount = mana
                    set udg_ManaTarget = target

                    if IS_NATIVE_MANA_SELF then
                        set udg_ManaSource = target
                    else
                        set udg_ManaSource = null   // Can't know the source of a native mana restoration sadly
                    endif
                 
                    set udg_IsSelfMana = IS_NATIVE_MANA_SELF

                    // Fire AfterManaEvent
                    set udg_AfterManaEvent  = 0.00
                    set udg_AfterManaEvent  = 1.00
                    set udg_AfterManaEvent  = 0.00
                else
                    // Check ManaRegen
                    set manaregen[unitIndex] = (manaregen[unitIndex] + diff) * 0.5

                    set manaregenBuildUp[unitIndex]     = manaregenBuildUp[unitIndex] + diff
                    set manaregenTimeLeft[unitIndex]    = manaregenTimeLeft[unitIndex] - MANA_CHECK_INTERVAL

                    if manaregenTimeLeft[unitIndex] <= 0.00 then
                        // reset clock
                        set manaregenTimeLeft[unitIndex] = MANA_REGEN_EVENT_INTERVAL

                        set mana = manaregenBuildUp[unitIndex]
                        set manaregenBuildUp[unitIndex] = 0.00
                     
                        set diff = mana

                        // Ignore manaregen from hero stats
                        if IsUnitType(target, UNIT_TYPE_HERO) then
                            set diff = diff - MANA_REGEN_INTELLIGENCE_VALUE * I2R(GetHeroInt(target, true))
                        endif

                        // Fire ManaRegen Event (AfterManaEvent = 0.5)
                        if diff > MANA_REGEN_THRESHOLD then
                             // Set Up variables
                            set udg_ManaAmount = mana
                            set udg_ManaTarget = target

                            if IS_NATIVE_MANA_REGEN_SELF then
                                set udg_ManaSource = target
                            else
                                set udg_ManaSource = null   // Can't know the source of a native mana restoration sadly
                            endif
                         
                            set udg_IsSelfMana = IS_NATIVE_MANA_REGEN_SELF

                            // Fire AfterManaEvent
                            set udg_AfterManaEvent  = 0.00
                            set udg_AfterManaEvent  = 0.50
                            set udg_AfterManaEvent  = 0.00
                        endif
                    endif
                endif

                set unitIndex = indexRef[unitIndex]
                set unitIndex = unitIndex +1
            endloop
        endmethod

        // Check unit new mana and fire AfterManaEvent if needed
        static method Adjust takes unit target returns nothing
            local integer index     = GetUnitUserData(target)
            local real u_mp         = GetUnitState(target, UNIT_STATE_MANA)
         
            local real mana = u_mp - lastMana[index] - manaregen[index] * TimerGetElapsed(manaTimer) / MANA_CHECK_INTERVAL

            if mana > MANA_THRESHOLD then
                set lastMana[index] = lastMana[index] + mana
             
                // Set Up variables
                set udg_ManaAmount = mana
                set udg_ManaTarget = target

                if IS_NATIVE_MANA_SELF then
                    set udg_ManaSource = target
                else
                    set udg_ManaSource = null   // Can't know the source of a native mana restoration sadly
                endif
             
                set udg_IsSelfMana = IS_NATIVE_MANA_SELF

                // Fire AfterManaEvent
                set udg_AfterManaEvent  = 0.00
                set udg_AfterManaEvent  = 1.00
                set udg_AfterManaEvent  = 0.00
            endif
        endmethod

        // Adjust values when unit takes damage, or mana might not be detected
        static method AdjustAfterDamage takes unit target, real dmg returns nothing
            local integer index     = GetUnitUserData(target)
            local real u_mp         = GetUnitState(target, UNIT_STATE_MANA)

            if dmg > 0 then
                set lastMana[index] = u_mp - manaregen[index] * TimerGetElapsed(manaTimer) / MANA_CHECK_INTERVAL
            else
                call Adjust(target)
            endif
        endmethod

        // Adjust after mana, avoiding a double event for one mana
        static method AdjustAfterMana takes unit u, real mana returns nothing
            local integer index = GetUnitUserData(u)
            set lastMana[index] = lastMana[index] + mana
        endmethod

        private static method ActionAddUnit takes nothing returns nothing
            call AddUnit(udg_UDex)
        endmethod

        private static method ActionRemoveUnit takes nothing returns nothing
            call SystemRemoveUnit(udg_UDex)
        endmethod

        private static method onInit takes nothing returns nothing
            if USE_MANA_DETECTION then
                set manaTimer           = CreateTimer()
                set checkLoopTrigger    = CreateTrigger()
                set addUnitTrigger      = CreateTrigger()
                set removeUnitTrigger   = CreateTrigger()

                call StartTimerBJ(manaTimer, true, MANA_CHECK_INTERVAL)
             
                call TriggerRegisterTimerExpireEvent(checkLoopTrigger, manaTimer)
                call TriggerAddAction(checkLoopTrigger, function ManaDetection.CheckLoop)

                call TriggerRegisterVariableEvent(addUnitTrigger, "udg_UnitIndexEvent", EQUAL, 1.00)
                call TriggerRegisterVariableEvent(addUnitTrigger, "udg_DeathEvent", EQUAL, 2.00)
                call TriggerAddAction(addUnitTrigger, function ManaDetection.ActionAddUnit)

                call TriggerRegisterVariableEvent(removeUnitTrigger, "udg_UnitIndexEvent", EQUAL, 2.00)
                call TriggerRegisterVariableEvent(removeUnitTrigger, "udg_DeathEvent", EQUAL, 0.50)
                call TriggerRegisterVariableEvent(removeUnitTrigger, "udg_DeathEvent", EQUAL, 1.00)
                call TriggerRegisterVariableEvent(removeUnitTrigger, "udg_DeathEvent", EQUAL, 3.00)
                call TriggerAddAction(removeUnitTrigger, function ManaDetection.ActionRemoveUnit)
            endif
        endmethod
    endstruct

    struct Mana

        /*
            Variables used in mana restoration
        */
        private unit manaSource
        private unit manaTarget

        private real manaBaseAmt
        private real manaPrevAmt
        private real manaAmount
     
        private real effectiveManaAmt
        private real overManaAmount

        private boolean isSelfMana
     
        /*
            Variables used for listing
        */
        private Mana next

        private static Mana first
        private static Mana last


        private static method create takes unit source, unit target, real amount returns Mana
            local Mana this = Mana.allocate()

            set this.manaSource         = source
            set this.manaTarget         = target
            set this.manaAmount         = amount
            set this.manaBaseAmt        = amount
            set this.manaPrevAmt        = amount

            set this.isSelfMana         = (source == target)
            set this.overManaAmount     = 0
            set this.effectiveManaAmt   = 0

            set this.next = 0
         
            return this
        endmethod

        private method destroy takes nothing returns nothing
            call this.deallocate()
        endmethod

        private static method onInit takes nothing returns nothing
            set first = 0
            set last = 0
        endmethod

        /*
            Entry point for user.
        */
        static method ManaUnit takes unit source, unit target, real amount returns nothing
            local Mana h = Mana.create(source, target, amount)

            if first == 0 then
                set first = h
                set last = h
                call Mana.Run()
            else
                set last.next = h
                set last = last.next
            endif

        endmethod

        // Put this instance members into GUI variables
        private method setEventVariables takes nothing returns nothing
            set udg_ManaSource              = this.manaSource
            set udg_ManaTarget              = this.manaTarget
         
            set udg_ManaAmount              = this.manaAmount
            set udg_ManaBaseAmount          = this.manaBaseAmt
            set udg_ManaPrvAmount           = this.manaPrevAmt
         
            set udg_EffectiveManaAmount     = this.effectiveManaAmt
            set udg_OverManaAmount          = this.overManaAmount

            set udg_IsSelfMana              = this.isSelfMana
        endmethod

        // Updates this instance members with GUI vars that might have been updated
        private method getEventVariables takes nothing returns nothing
            set this.manaSource     = udg_ManaSource
            set this.manaTarget     = udg_ManaTarget
            set this.manaAmount     = udg_ManaAmount
            set this.manaPrevAmt    = udg_ManaAmount    // Stores this step result for reference in next step if needed.

            set this.isSelfMana     = (this.manaSource == this.manaTarget)
        endmethod

        // Reset Variables to a neutral state
        private static method resetEventVariables takes nothing returns nothing
            set udg_ManaSource              = null
            set udg_ManaTarget              = null

            set udg_ManaBaseAmount          = 0.00
            set udg_ManaPrvAmount           = 0.00
            set udg_ManaAmount              = 0.00

            set udg_EffectiveManaAmount     = 0.00
            set udg_OverManaAmount          = 0.00

            set udg_IsSelfMana              = false
        endmethod

        /*
            Function where the hmana restoration and Events are done.
            Mana restoration are dealt one at the time. Mana restoration created during Events will be postponed.
        */
        private static method Run takes nothing returns nothing
            local Mana h
            local integer u_custom
            local real u_current_mp
            local real u_max_mp
            local real u_missing_mp
            local real new_missing_mp
            local real i = 1.00

            loop
                exitwhen first == null
             
                set h = first
             
                // Using not == instead of !=; the idea is to eliminate floating point bugs when two numbers are very close to 0,
                // because JASS uses a less-strict comparison for checking if a number is equal than when it is unequal.
                if not (h.manaAmount == 0.00) then

                    loop
                        exitwhen i > MAX_PREMANA_EVENTS
                        // Set GUI vars
                        call h.setEventVariables()

                        // Fire PreManaEvent
                        set udg_PreManaEvent    = 0.00
                        set udg_PreManaEvent    = i
                        set udg_PreManaEvent    = 0.00

                        // Update fields in case event was caught and variables changed.
                        call h.getEventVariables()

                        set i = i +1.00
                    endloop

                    if not ALLOW_NEGATIVE_MANA and h.manaAmount < 0.00 then
                        set h.manaAmount = 0.00
                    endif                     
                 
                    // Get target infos
                    set u_custom            = GetUnitUserData(h.manaTarget)
                    set u_max_mp            = GetUnitState(h.manaTarget, UNIT_STATE_MAX_MANA)
                    set u_current_mp         = GetUnitState(h.manaTarget, UNIT_STATE_MANA)
                    set u_missing_mp        = u_max_mp - u_current_mp
                 
                    if h.manaAmount > 0 then
                        // Mana Restoration itself.
                        call SetUnitState(h.manaTarget, UNIT_STATE_MANA, u_current_mp + h.manaAmount)
                     
                        // Getting new missing mp
                        set new_missing_mp = GetUnitState(h.manaTarget, UNIT_STATE_MAX_MANA) - GetUnitState(h.manaTarget, UNIT_STATE_MANA)

                        // Computing effective mana restoration and possible overmana restoration
                        set h.effectiveManaAmt = u_missing_mp - new_missing_mp
                        set h.overManaAmount = h.manaAmount - h.effectiveManaAmt
                    else
                        // Use Damage function to be compatible with damage engines
                        call UnitDamageTargetBJ(h.manaSource, h.manaTarget, h.manaAmount, ATTACK_TYPE_MAGIC, DAMAGE_TYPE_MAGIC)
                        set h.effectiveManaAmt = h.manaAmount
                    endif
                 
                    // Fire OverManaEvent
                    if h.overManaAmount > OVERMANA_THRESHOLD then
                        // Set GUI vars
                        call h.setEventVariables()

                        set udg_OverManaEvent   = 0.00
                        set udg_OverManaEvent   = 1.00
                        set udg_OverManaEvent   = 0.00
                    endif

                    // Fire AfterManaEvent if enough mana restoration was done, else ZeroManaEvent
                    if h.effectiveManaAmt > ZEROMANA_THRESHOLD or (h.overManaAmount > 0.00) then
                        // Update ManaDetection system, avoiding the event triggering twice for this mana restoration
                        call ManaDetection.AdjustAfterMana(h.manaTarget, h.manaAmount)

                        // Set GUI vars
                        call h.setEventVariables()

                        set udg_AfterManaEvent  = 0.00
                        set udg_AfterManaEvent  = 1.00
                        set udg_AfterManaEvent  = 0.00
                    elseif h.effectiveManaAmt < NEGATIVE_MANA_THRESHOLD then
                        // Set GUI vars
                        call h.setEventVariables()

                        set udg_NegativeManaEvent   = 0.00
                        set udg_NegativeManaEvent   = 1.00
                        set udg_NegativeManaEvent   = 0.00
                    else
                        // Set GUI vars
                        call h.setEventVariables()

                        set udg_ZeroManaEvent   = 0.00
                        set udg_ZeroManaEvent   = 1.00
                        set udg_ZeroManaEvent   = 0.00
                    endif

                endif

                // Resets variables
                call resetEventVariables()

                // Set the next mana that will be run
                set first = h.next
             
                // Free resources
                call h.destroy()
            endloop

        endmethod
    endstruct

endlibrary

Heal & Mana Engine v2.0.0

 

[Marchombre]

Heal & Mana Engine v2.0.0

Hello,

Sorry, didn't have time to look at what you send yet.
Will check all of this during this week.

Besides the new mana engine, did you change anything to the heal engine itself that I should also see ?

 

[Kotol]

Hello,

Sorry, didn't have time to look at what you send yet.
Will check all of this during this week.

Besides the new mana engine, did you change anything to the heal engine itself that I should also see ?

No changes on Heal Engine.
I just add-on Mana Engine which is based on Heal Engine.

 

[Marchombre]

Didn't have much time to look into it, as I was working on other projects, but it seems that some mana modifications aren't applying correctly, or not at the correct step.
I want to make sure everything is fine before adding to official release.

Plus, I think I'll add a thing to make mana restoration and mana burn 2 different things with distinct events, with options to make negative restoration either 0 or count as mana burn, and negative mana burn either 0 or count as restoration.

 

[Kotol]

Didn't have much time to look into it, as I was working on other projects, but it seems that some mana modifications aren't applying correctly, or not at the correct step.
I want to make sure everything is fine before adding to official release.

Plus, I think I'll add a thing to make mana restoration and mana burn 2 different things with distinct events, with options to make negative restoration either 0 or count as mana burn, and negative mana burn either 0 or count as restoration.

The problem might be originating from the GetWidgetLife(h.healTarget) function. Since the GetWidgetMana() function is missing, I used GetUnitState(h.manaTarget, UNIT_STATE_MANA) instead.

Adding mana restoration and mana burn as two separate mechanics would make more sense, in my opinion.