Triggers

//TESH.scrollpos=75
//TESH.alwaysfold=0
///////////////////////////////////////////////////////////////////////////////////////////

MY CHILD IS BACK OMG I WAS SO SAD DURING THIS ONE MONTH (20/10/21 - 23/11/21)

///////////////////////////////////////////////////////////////////////////////////////////

anyway  

vfx effects are currently broken sadge

stat gain balance across all heroes, now total stat gain varies from 10-12

item adjustments

revitalizing scroll renamed to revitalizing parchment
talisman of evasion evasion from 30 to 25



aqa r pulse fx decreased

bo e reworked to equilibrium
bo r reworked, attacks now spend mana and defense gains mana, ui improvements

bt p tentacles no longer gain aspd per level

dc cleanup
dc q no longer scales with strength, vfx fixed
dc w manacost decreased
dc r damage decreased

em p hp regen moved to stacks, recoded with endurance aura
em r damage decreased
em r reworked, now requires auto weaving

fmd rework
fmd p no longer costs mana, no longer has primary attack, bullets scale with agi
fmd q no longer slows
fmd new w supersonic shift blink clap
fmd r adjusted to work with passive

fs r scaling decreased

gs q damage decreased early

gw rework

gw q now only shoots one volley
gw w combined into e
new gw w - arcane sentry, creates a tower
gw e reworked into metallic flare
gw r reworked into crushing upheaval

hq p cd smoothen
hq q damage increased late, range modified
hq e now hits nonheroes 

in p no longer displays text against creeps

lm abilities no longer scale with bonus int, compensation buffed
lm q2 moved to lm p 
lm e max shield increased


ma rework
ma p - mark of the archfiend (from e) renamed to baleful warning
ma qw numbers changed in general
ma e new ability umbral veil, invulnerability
ma r damage changed in general
ma t demonic portal from p

mf e aoe increased

nr q damage decreased early

os p to sh p, new p sewalls vengeance
os qwer damage lower early
os q aoe increased
os w aoe decreased
os r cannot move himself anymore

pp p now has a 0.3 fade time

rb update
rb p cleaned up rage system, added qol stuff like decaying out of combat
rb w renamed to regenerative tissue
rb e now deals two instances of damage 
rb r added to rb p, new ability infernal rage, short steroid

sh p deathly presence - os p

sr cooldowns and numbers changed in general

wa p recoded, now scales with hero level (also buffed hehheh)
wa w now amplifies damage instead of firing another beam
wa r now fires beams in fixed angles instead

//TESH.scrollpos=101
//TESH.alwaysfold=0
////////////////////////////////////////////////////////////////////////////////////
//
//  Physical Damage Detection Engine GUI v 1.3.0.0
//  ----------------------------------------------
//  By looking_for_help aka eey
//
//  This system is able to detect, modify and deal damage. It can differentiate
//  between physical and spell damage, as well as block, reduce or increase the
//  applied damage to a desired value. You can also allocate damage events from
//  running damage events.
//
//  This is the GUI version of the system, meaning that you can use this with the
//  standard editor and basically without any knowledge of JASS.
//
////////////////////////////////////////////////////////////////////////////////////
//
//  Implementation
//  --------------
//  1.  Create all variables that this system uses (compare the variable editor).
//      You don't have to set them to specific values, they get initialized
//      automatically by the system so just create them.
//  2.  Copy this trigger to your map. You can then add damage handlers by using
//      the event "value of real variable becomes equal to 1" with the variable
//      udg_PDD_damageEventTrigger. Compare the OnDamage trigger for an example usage.
//  3.  Copy the two custom abilities to your map and make sure they have the
//      correct ID. You can specify the ID in the function InitGlobalVariables
//      above.
//  4.  Go to the locust swarm ability and invert its damage return portion
//      from (default) 0.75 to -0.75.
//  5.  Remove the spell damage reduction ability from the spell damage reduction
//      items you use (runed bracers). You can configure the resistance of this
//      item in the InitGlobalVariables function, modifying the global variable
//      udg_PDD_BRACERS_SPELL_DMG_RED.
//
////////////////////////////////////////////////////////////////////////////////////
//
//  Important Notes
//  ---------------
//  1.  Life Drain does not work with this system, so you should use a triggered
//      version of this spell if you want to use it.
//  2.  Same for Finger of Death, if you want to use this spell bug free with this
//      system, you should use a triggered version of it.
//  3.  If you use damage modifiers by setting the damage amount variable, you have
//      to use GetUnitLife, GetUnitMaxLife and SetUnitLife instead of GetWidgetLife,
//      GetUnitState for UNIT_STATE_MAX_LIFE and SetWidgetLife in your whole map to
//      ensure there occure no bugs.
//  4.  The boolean udg_PDD_SPELL_RESIST_AUTO_DETECT is only neccessary set to true
//      if you want to use a customized damage table with spell damage resistance
//      above 100%. If this is not the case, it should be set to false, as the
//      system is faster then and still works correct.
//  5.  As already mentioned you can't use the spell reduction ability when using this
//      system (runed bracers and elunes grace). If you want to use them, you can
//      trigger them by using the damage modifiers. Runed bracers is already considered
//      in this system, so you don't have to code it.
//
////////////////////////////////////////////////////////////////////////////////////
//  
//  System API
//  ----------
//  real damageEventTrigger
//      - Use the event "value of real variable becomes equal to 1" to detect a damage
//        event. In this event you can use the following API. Compare the OnDamage
//        trigger for an example usage.
//
//  unit target
//      - In this global unit variable, the damaged unit is saved. Don't write any-
//        thing into this variable, use it as readonly.
//
//  unit source
//      - In this global unit variable, the damage source is saved. Don't write any-
//        thing into this variable, use it as readonly.
//
//  real amount
//      - In this global real variable, the amount of damage is saved. This amount
//        can be modified by simply setting it to the desired amount that should be
//        applied to the target. Set the amount to 0.0 to block the damage completely.
//        Negative values will result in heal.
//
//  integer damageType
//      - In this global integer variable, the damage type of the current damage is
//        saved. Use it to differentiate between physical, spell and code damage. The
//        variable can takes the values PHYSICAL == 0, SPELL == 1 and CODE == 2. Don't
//        write anything into this variable, use it as readonly.        
//
//  function GetUnitLife takes unit u returns real
//      - Use this function instead of the GetWidgetLife native. It ensures that you
//        get the correct health value, even when damage modifiers are applied. If
//        you don't use damage modifiers at all, you don't need this function.
//
//  function GetUnitMaxLife takes unit u returns real
//      - Use this function instead of the GetUnitState(u, UNIT_STATE_MAX_LIFE) native.
//        It will return the correct value, even when damage modifiers are applied. If
//        you don't use damage modifiers at all, you don't need this function.
//
//  function SetUnitLife takes unit u, real newLife returns nothing
//      - Use this function instead of the SetWidgetLife(u, newLife) native if you use
//        damage modifiers in your map. Same rules as for the GetUnitMaxLife and the
//        GetUnitMaxLife functions.
//
//  function UnitDamageTargetEx takes unit localSource, unit localTarget, real localAmount, boolean attack, boolean ranged, attacktype localAttackType, damagetype localDamageType, weapontype localWeaponType returns boolean
//      - Use this function to deal damage from a running damage event. It works exactly
//        the same as the native UnitDamageTarget but is recursion safe so that you can
//        realize damage reflection for example with this. Don't ever use this function
//        outside of an onDamage event. 
//
//  function AddDamageHandler takes code damageHandler returns nothing
//      - Allows you to add a damage handler function to the system. This is not
//        required for GUI users, only for vanilla JASS users. GUI users should
//        use the real variable damageEventTrigger to add damage handlers to this
//        system as explained above.
//
//  function RemoveDamageHandler takes code damageHandler returns nothing
//      - Allows you to remove a damage handler function from the system dynamic-
//        ally. If you added the same handler function multiple times to the sys-
//        tem, this function will remove all of these equal functions. This is not
//        required for GUI users, only for vanilla JASS users.
//
//////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////
//  Sub functions
////////////////////////////////////////////////////////////////////////////////////

function DealFixDamage takes unit source, unit target, real pureAmount returns nothing
    local real MAX_DAMAGE = 1000000.0
    local real beforeHitpoints
    local real newHitpoints

    // Ensure the amount is positive
    if pureAmount < 0 then
        set pureAmount = -pureAmount
    endif

    // Save the targets hitpoints
    set beforeHitpoints = GetWidgetLife(target)
    set newHitpoints = beforeHitpoints - pureAmount

    // Apply the desired, fixed amount
    if newHitpoints >= udg_PDD_UNIT_MIN_LIFE then
        call SetUnitState(target, UNIT_STATE_LIFE, newHitpoints)
    else
        if ( IsUnitType(target, UNIT_TYPE_ETHEREAL) == false ) then
            call SetWidgetLife(target, 1.0)
            call UnitDamageTarget(source, target, MAX_DAMAGE, true, false, udg_PDD_ATTACK_TYPE_UNIVERSAL, DAMAGE_TYPE_UNIVERSAL, null)
            call SetWidgetLife(target, 0.0)
        else
            call UnitRemoveAbility(target, udg_PDD_DAMAGE_TYPE_DETECTOR)
            call SetWidgetLife(target, 1.0)
            call UnitDamageTarget(source, target, MAX_DAMAGE, true, false, ATTACK_TYPE_NORMAL, DAMAGE_TYPE_UNIVERSAL, null)
            call SetWidgetLife(target, 0.0)
        endif
    endif
endfunction

function GetUnitSpellResistance takes unit u returns real
    local real originalHP
    local real beforeHP
    local real afterHP
    local real resistance
    local real DUMMY_DAMAGE = 100
    local real DUMMY_FACTOR = 0.01
   
    // Deal spell damage in order to get the units resistance
    call UnitRemoveAbility(udg_PDD_target, udg_PDD_DAMAGE_TYPE_DETECTOR)
    set originalHP = GetWidgetLife(udg_PDD_target)
    call UnitAddAbility(udg_PDD_target, udg_PDD_SET_MAX_LIFE)
    call SetWidgetLife(udg_PDD_target, 20000.0)
    set beforeHP = GetWidgetLife(udg_PDD_target)
    call DisableTrigger(udg_PDD_damageEvent)
    call UnitDamageTarget(udg_PDD_source, udg_PDD_target, DUMMY_DAMAGE, true, false, null, DAMAGE_TYPE_UNIVERSAL, null)
    call EnableTrigger(udg_PDD_damageEvent)
    set afterHP = GetWidgetLife(udg_PDD_target)
    call UnitRemoveAbility(udg_PDD_target, udg_PDD_SET_MAX_LIFE)
    call SetWidgetLife(udg_PDD_target, originalHP)
    call UnitAddAbility(udg_PDD_target, udg_PDD_DAMAGE_TYPE_DETECTOR)
    call UnitMakeAbilityPermanent(udg_PDD_target, true, udg_PDD_DAMAGE_TYPE_DETECTOR)

    // Calculate this resistance
    set resistance = DUMMY_FACTOR*(beforeHP - afterHP)

    // If the resistance was greater than 100%, return it
    if resistance > 1.0 then
        return resistance
    else
        return 1.0
    endif
endfunction

function UnitHasItemOfType takes unit u, integer itemId returns integer
    local integer index = 0
    local item indexItem

    // Check if the target has a spell damage reducing item
    loop
        set indexItem = UnitItemInSlot(u, index)
        if ( indexItem != null ) and ( GetItemTypeId(indexItem) == itemId ) then
			set indexItem = null
            return index + 1
        endif

        set index = index + 1
        exitwhen index >= bj_MAX_INVENTORY
    endloop
	set indexItem = null
    return 0
endfunction


////////////////////////////////////////////////////////////////////////////////////
//  Damage Engine
////////////////////////////////////////////////////////////////////////////////////

function AfterDamage takes nothing returns nothing
    local timer time = GetExpiredTimer()
    local integer id = GetHandleId(time)
    local unit localSource = LoadUnitHandle(udg_PDD_h, id, 0)
    local unit localTarget = LoadUnitHandle(udg_PDD_h, id, 1)
    local real pureAmount = LoadReal(udg_PDD_h, id, 2)
    local real amount = LoadReal(udg_PDD_h, id, 3)
    local real originalHealth = LoadReal(udg_PDD_h, id, 4)

    // If the damage was modified, restore units health
    if originalHealth != 0.0 then
        call UnitRemoveAbility(localTarget, udg_PDD_SET_MAX_LIFE)
        call SetWidgetLife(localTarget, originalHealth)
    endif

    // Apply the desired amount of damage
    if amount > 0.0 then
        call DisableTrigger(udg_PDD_damageEvent)
        call DealFixDamage(localSource, localTarget, amount)
        call EnableTrigger(udg_PDD_damageEvent)
    else
        call SetWidgetLife(localTarget, originalHealth - amount)
    endif
   
    // Clean things up
    call FlushChildHashtable(udg_PDD_h, id)
    call FlushChildHashtable(udg_PDD_h, GetHandleId(localTarget))
    call DestroyTimer(time)
    set time = null
    set localSource = null
    set localTarget = null
endfunction

function DamageEngine takes nothing returns nothing
    local timer time
    local integer id
    local real health
    local real rawAmount
    local real originalHealth
    local integer targetId
    local integer oldTimerId
    local real oldHealth
    local real oldOriginalHealth
    local real oldAmount
    
    set rawAmount = GetEventDamage()
    if rawAmount == 0.0 then
        return
    endif
    set udg_PDD_source = GetEventDamageSource()
    set udg_PDD_target = GetTriggerUnit()
   
    // Determine the damage type
    if rawAmount > 0.0 then
        if udg_PDD_damageType != udg_PDD_CODE then
            set udg_PDD_damageType = udg_PDD_PHYSICAL
        endif
        set udg_PDD_amount = rawAmount
    else
        if udg_PDD_damageType != udg_PDD_CODE then
            set udg_PDD_damageType = udg_PDD_SPELL
        endif
        set udg_PDD_amount = -rawAmount
    endif
   
    // Register spell reduction above 100%
    if udg_PDD_SPELL_RESIST_AUTO_DETECT then
        set udg_PDD_amount = GetUnitSpellResistance(udg_PDD_target)*udg_PDD_amount
    else
        if ( IsUnitType(udg_PDD_target, UNIT_TYPE_ETHEREAL) and IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source)) and rawAmount < 0.0 ) then
            set udg_PDD_amount = udg_PDD_ETHEREAL_DAMAGE_FACTOR*udg_PDD_amount
        endif
    endif
   
    // Register spell damage reducing items like runed bracers
    if ( IsUnitType(udg_PDD_target, UNIT_TYPE_HERO) and UnitHasItemOfType(udg_PDD_target, udg_PDD_SPELL_DMG_REDUCTION_ITEM) > 0 ) and rawAmount < 0.0 then
        set udg_PDD_amount = (1 - udg_PDD_BRACERS_SPELL_DMG_RED)*udg_PDD_amount
    endif
   
    // Save health and damage variables
    if udg_PDD_damageType != udg_PDD_CODE then
        call UnitRemoveAbility(udg_PDD_target, udg_PDD_SET_MAX_LIFE)
    endif
    set udg_PDD_pureAmount = udg_PDD_amount
    set originalHealth = GetWidgetLife(udg_PDD_target)
    set oldTimerId = 0
   
    // Call damage handlers
	set udg_PDD_damageEventTrigger = 0.0
    set udg_PDD_damageEventTrigger = 1.0
    set udg_PDD_damageEventTrigger = 0.0

    // If the damage was modified, apply the rescue ability
    if udg_PDD_amount != udg_PDD_pureAmount then
        call UnitAddAbility(udg_PDD_target, udg_PDD_SET_MAX_LIFE)
        call SetWidgetLife(udg_PDD_target, GetWidgetLife(udg_PDD_target) + udg_PDD_pureAmount)
    endif
   
    // Check if a previous timer didn't yet expire
    set targetId = GetHandleId(udg_PDD_target)
    set oldHealth = LoadReal(udg_PDD_h, targetId, 0)
   
    // If this is the case, update the timer information
    if oldHealth != 0.0 then
        set oldTimerId = LoadInteger(udg_PDD_h, targetId, 3)
        set oldOriginalHealth = LoadReal(udg_PDD_h, targetId, 2)
        set oldAmount = LoadReal(udg_PDD_h, targetId, 1)
        set originalHealth = oldOriginalHealth - oldAmount
        call SaveReal(udg_PDD_h, oldTimerId, 4, oldOriginalHealth)
    endif

    // Call after damage event if damage was spell, modified, code or parallel
    if ( rawAmount < 0.0 or udg_PDD_pureAmount != udg_PDD_amount or oldTimerId != 0 or udg_PDD_allocatedAttacks > 0 ) then
        set time = CreateTimer()
        set id = GetHandleId(time)
       
        // Save handles for after damage event
        call SaveUnitHandle(udg_PDD_h, id, 0, udg_PDD_source)
        call SaveUnitHandle(udg_PDD_h, id, 1, udg_PDD_target)
        call SaveReal(udg_PDD_h, id, 2, udg_PDD_pureAmount)
        call SaveReal(udg_PDD_h, id, 3, udg_PDD_amount)
        call SaveReal(udg_PDD_h, id, 4, originalHealth)

        // Save this extra to manage parallel damage instances
        call SaveReal(udg_PDD_h, targetId, 0, GetWidgetLife(udg_PDD_target))
        call SaveReal(udg_PDD_h, targetId, 1, udg_PDD_amount)
        call SaveReal(udg_PDD_h, targetId, 2, originalHealth)
        call SaveInteger(udg_PDD_h, targetId, 3, id)

        // Avoid healing of negative spell damage
        if rawAmount < 0.0 then
            call DisableTrigger(udg_PDD_damageEvent)
            call DealFixDamage(udg_PDD_source, udg_PDD_target, -rawAmount)
            if ( originalHealth - udg_PDD_amount < udg_PDD_UNIT_MIN_LIFE ) then
                call UnitRemoveAbility(udg_PDD_target, udg_PDD_SET_MAX_LIFE)
                call DealFixDamage(udg_PDD_source, udg_PDD_target, udg_PDD_amount)
            endif
            call EnableTrigger(udg_PDD_damageEvent)
        endif
       
        // Guarantee unit exploding
        if originalHealth - udg_PDD_amount < udg_PDD_UNIT_MIN_LIFE then
            if rawAmount > 0.0 then
                call UnitRemoveAbility(udg_PDD_target, udg_PDD_SET_MAX_LIFE)
                call SetWidgetLife(udg_PDD_target, udg_PDD_UNIT_MIN_LIFE)
            endif
        endif
       
        // Start the after damage event
        call TimerStart(time, 0.0, false, function AfterDamage)
    endif

    // Handle allocated attacks from UnitDamageTargetEx
    if udg_PDD_totalAllocs == 0 then
        set udg_PDD_totalAllocs = udg_PDD_allocatedAttacks
    endif
    if udg_PDD_allocatedAttacks > 0 then
        set udg_PDD_allocatedAttacks = udg_PDD_allocatedAttacks - 1
        set udg_PDD_allocCounter = udg_PDD_allocCounter + 1
        call TriggerEvaluate(udg_PDD_runAllocatedAttacks)
    endif

    // Reset all required variables
    set udg_PDD_damageType = -1
    set udg_PDD_totalAllocs = 0
    set udg_PDD_allocCounter = -1
endfunction


////////////////////////////////////////////////////////////////////////////////////
//  Initialization
////////////////////////////////////////////////////////////////////////////////////

function RestoreTriggers takes nothing returns nothing
    local unit enumUnit = GetEnumUnit()

    // Re-register units that are alive
    if GetUnitTypeId(enumUnit) != 0 then
        call TriggerRegisterUnitEvent(udg_PDD_damageEvent, enumUnit, EVENT_UNIT_DAMAGED)
    endif
    set enumUnit = null
endfunction

function ClearMemory_Actions takes nothing returns nothing
    local group g = CreateGroup()
    local code c = function DamageEngine
   
    // Reset the damage event
    call GroupEnumUnitsInRect(g, GetWorldBounds(), null)
    call ResetTrigger(udg_PDD_damageEvent)
    call DestroyTrigger(udg_PDD_damageEvent)
    set udg_PDD_damageEvent = null
   
    // Rebuild it then
    set udg_PDD_damageEvent = CreateTrigger()
    call TriggerAddCondition(udg_PDD_damageEvent, Filter(c))
    call ForGroup(g, function RestoreTriggers)
   
    // Clean things up
    call DestroyGroup(g)
    set g = null
    set c = null
endfunction

function MapInit takes nothing returns nothing
    local unit enumUnit = GetEnumUnit()

    // Register units on map initialization
    call UnitAddAbility(enumUnit, udg_PDD_DAMAGE_TYPE_DETECTOR)
    call UnitMakeAbilityPermanent(enumUnit, true, udg_PDD_DAMAGE_TYPE_DETECTOR)
    call TriggerRegisterUnitEvent(udg_PDD_damageEvent, enumUnit, EVENT_UNIT_DAMAGED)
    set enumUnit = null
endfunction

function UnitEntersMap takes nothing returns nothing
    local unit triggerUnit = GetTriggerUnit()

    // Register units that enter the map
    if ( GetUnitAbilityLevel(triggerUnit, udg_PDD_DAMAGE_TYPE_DETECTOR) < 1 ) then
        call UnitAddAbility(triggerUnit, udg_PDD_DAMAGE_TYPE_DETECTOR)
        call UnitMakeAbilityPermanent(triggerUnit, true, udg_PDD_DAMAGE_TYPE_DETECTOR)
        call TriggerRegisterUnitEvent(udg_PDD_damageEvent, triggerUnit, EVENT_UNIT_DAMAGED)
    endif
    set triggerUnit = null
endfunction

function RunAllocatedAttacks takes nothing returns nothing
    local integer localAllocAttacks = udg_PDD_allocatedAttacks + 1

    // Calculate the correct sequence of allocated attacks
    set localAllocAttacks = localAllocAttacks - udg_PDD_totalAllocs + 1 + 2*udg_PDD_allocCounter
   
    // Deal code damage if the unit isn't exploding
    set udg_PDD_damageType = udg_PDD_CODE
    if GetUnitLife(LoadUnitHandle(udg_PDD_h, localAllocAttacks, 1)) >= udg_PDD_UNIT_MIN_LIFE then
        call UnitDamageTarget(LoadUnitHandle(udg_PDD_h, localAllocAttacks, 0), LoadUnitHandle(udg_PDD_h, localAllocAttacks, 1), LoadReal(udg_PDD_h, localAllocAttacks, 2), LoadBoolean(udg_PDD_h, localAllocAttacks, 3), LoadBoolean(udg_PDD_h, localAllocAttacks, 4), ConvertAttackType(LoadInteger(udg_PDD_h, localAllocAttacks, 5)), ConvertDamageType(LoadInteger(udg_PDD_h, localAllocAttacks, 6)), ConvertWeaponType(LoadInteger(udg_PDD_h, localAllocAttacks, 7)))
    else
        call FlushChildHashtable(udg_PDD_h, localAllocAttacks - 1)
    endif
   
    // Clean things up
    call FlushChildHashtable(udg_PDD_h, localAllocAttacks)
endfunction

function InitTrig_DamageEvent takes nothing returns nothing
    local group g = CreateGroup()
    local region r = CreateRegion()
    local trigger UnitEnters = CreateTrigger()
    local trigger ClearMemory = CreateTrigger()
    local code cDamageEngine = function DamageEngine
    local code cUnitEnters = function UnitEntersMap
    local code cClearMemory = function ClearMemory_Actions
    local code cRunAllocatedAttacks = function RunAllocatedAttacks
   
    // Initialize global variables
    set udg_PDD_h = InitHashtable()
    set udg_PDD_damageEvent = CreateTrigger()
    set udg_PDD_damageHandler = CreateTrigger()
    set udg_PDD_damageType = -1
    set udg_PDD_allocatedAttacks = 0
    set udg_PDD_runAllocatedAttacks = CreateTrigger()
   
    // Initialize global configurable constants
    call InitGlobalVariables()
   
    // Initialize global fixed constants
    set udg_PDD_PHYSICAL = 0
    set udg_PDD_SPELL = 1
    set udg_PDD_CODE = 2
    set udg_PDD_UNIT_MIN_LIFE = 0.406
    set udg_PDD_ATTACK_TYPE_UNIVERSAL = ConvertAttackType(7)
    set udg_PDD_totalAllocs = 0
    set udg_PDD_allocCounter = -1
    set udg_PDD_damageEventTrigger = 0.0
   
    // Register units on map initialization
    call TriggerRegisterVariableEvent(udg_PDD_damageHandler, "udg_PDD_damageEventTrigger", EQUAL, 1.0)
    call TriggerAddCondition(udg_PDD_damageEvent, Filter(cDamageEngine))  
    call GroupEnumUnitsInRect(g, GetWorldBounds(), null)
    call ForGroup(g, function MapInit)
   
    // Register units that enter the map
    call RegionAddRect(r, GetWorldBounds())
    call TriggerRegisterEnterRegion(UnitEnters, r, null)
    call TriggerAddCondition(UnitEnters, Filter(cUnitEnters))
   
    // Register trigger for allocated attacks
    call TriggerAddCondition(udg_PDD_runAllocatedAttacks, Filter(cRunAllocatedAttacks))
   
    // Clear memory leaks
    call TriggerRegisterTimerEvent(ClearMemory, udg_PDD_TRIGGER_CLEANUP_PERIOD, true)
    call TriggerAddCondition(ClearMemory, Filter(cClearMemory))

    // Clean things up
    call DestroyGroup(g)
    set UnitEnters = null
    set ClearMemory = null
    set cDamageEngine = null
    set cUnitEnters = null
    set cClearMemory = null
    set cRunAllocatedAttacks = null
    set g = null
    set r = null
endfunction

//TESH.scrollpos=1057
//TESH.alwaysfold=0
function Trig_SpellDummy_PDD_Conditions takes nothing returns boolean
    if ( not ( IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source)) == true ) ) then
        return false
    endif
    if ( not ( udg_PDD_damageType == udg_PDD_SPELL ) ) then
        return false
    endif
    if ( not ( GetUnitTypeId(udg_PDD_source) == 'h01S' ) ) then
        return false
    endif
    if ( IsUnitType(udg_PDD_target, UNIT_TYPE_HERO ) ) then
        return false
    endif
    return true
endfunction

function Trig_SpellDummy_PDD_Actions takes nothing returns nothing
    set udg_PDD_amount = udg_PDD_amount * 0.75
endfunction

function Trig_SpellAmp_PDD_Conditions takes nothing returns boolean
    local boolean a = GetUnitAbilityLevel(udg_PDD_source, 'A07O') > 0
    local boolean b = not IsUnitType(udg_PDD_target,UNIT_TYPE_STRUCTURE)
    return a and b
endfunction

function Trig_SpellAmp_PDD_Actions takes nothing returns nothing
    if IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source)) then
        set udg_PDD_amount = udg_PDD_amount * 0.01 * GetUnitUserData(udg_PDD_source)
        if (GetUnitAbilityLevel(udg_PDD_target, 'A0DA') > 0) then
            set udg_PDD_amount = udg_PDD_amount * 0.75
        endif
    else 
        set udg_PDD_amount = 0
    endif
    //call DisplayTextToForce( GetPlayersAll(), R2S(udg_PDD_amount) )
endfunction

function Trig_SpellComp_PDD_Conditions takes nothing returns boolean
    if ( not ( IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source)) == true ) ) then
        return false
    endif
    if ( not ( GetUnitTypeId(udg_PDD_source) == 'h02A' ) ) then
        return false
    endif
    if ( IsUnitType (udg_PDD_target,UNIT_TYPE_STRUCTURE) ) then
        return false
    endif
    return true
endfunction

function Trig_SpellComp_PDD_Actions takes nothing returns nothing
    local unit d
    local location p = GetUnitLoc(udg_PDD_target)
    local real x
    local real r
    local string s
    //aquaforce avatar - whirlpool strike
    if GetUnitAbilityLevel(udg_PDD_source, 'A02C') > 0 then
        set d = CreateUnitAtLoc( GetOwningPlayer(udg_PDD_source), 'h01Y', p , 0 )
        call UnitAddAbility( d, 'A040' )
        call SetUnitUserData(d, GetUnitUserData(udg_PDD_source) )
        call IssueImmediateOrder( d, "thunderclap" )
    endif
    //dark ninja - dark spear
    if GetUnitAbilityLevel(udg_PDD_source, 'A04O') > 0 then
        set x = 0.005 * (180.00 - GetUnitPercentLife(udg_PDD_target))
        set r = x * GetUnitUserData(udg_PDD_source) * 0.01
        set udg_PDD_amount = udg_PDD_amount * r
        //call FadingText( ( I2S(R2I(udg_PDD_amount)) + s ), udg_PDD_target, 10, 40, 40, 40, 0 )
    endif
    //goddess of the seas - curse
    if GetUnitAbilityLevel(udg_PDD_source, 'A0C5') > 0 then
        set x = 0.016 + 0.0005 * GetUnitUserData(udg_PDD_source)
        set r = x * GetUnitMissingLife(udg_PDD_target)
        set udg_PDD_amount = udg_PDD_amount + r
        call FadingText( ( I2S(R2I(r)) + "!" ), udg_PDD_target, 11, 80, 84, 84, 0 )
    endif
    //malicious archfiend - quietus
    if GetUnitAbilityLevel(udg_PDD_source, 'A0CJ') > 0 then
        set r = GetUnitUserData(udg_PDD_source)*0.01
        set d = CreateUnitAtLoc(GetOwningPlayer(udg_PDD_source),'h000', p, 0)
        call UnitAddAbility(d, 'A0AM')
        set udg_PDD_amount = udg_PDD_amount * r
        //call UnitDamageTargetPDD( udg_PDD_source, udg_PDD_target, r, 1 )
        call IssueTargetOrder(d, "soulburn", udg_PDD_target)
    endif
    //pyrotactician - shrapnel
    if GetUnitAbilityLevel(udg_PDD_source, 'A022') > 0 then
        set r = GetUnitUserData(udg_PDD_source)*0.01
        set d = CreateUnitAtLoc(GetOwningPlayer(udg_PDD_source),'h000', p, 0)
        call UnitAddAbility(d, 'A00I')
        set udg_PDD_amount = udg_PDD_amount * r
        //call UnitDamageTargetPDD( udg_PDD_source, udg_PDD_target, r, 1 )
        call IssueTargetOrder(d, "slow", udg_PDD_target)
    endif
    //relucent hunter - paralyzing chain
    if GetUnitAbilityLevel(udg_PDD_source, 'A06I') > 0 then
        set r = GetUnitUserData(udg_PDD_source)
        set d = CreateUnitAtLoc(GetOwningPlayer(udg_PDD_source),'h000', p, 0)
        call UnitAddAbility(d, 'A05E')
        call UnitDamageTargetPDD( udg_PDD_source, udg_PDD_target, r, 1 )
        call IssueTargetOrder(d, "firebolt", udg_PDD_target)
    endif
    set d = null
    call RemoveLocation (p)
endfunction

function Trig_PDD_Filter takes nothing returns boolean
    local boolean a = IsUnitEnemy(GetFilterUnit(), GetOwningPlayer(udg_PDD_source))
    local boolean b = GetFilterUnit() != udg_PDD_target
    return (a and b and IsTarget())
endfunction

function Trig_AA_PDD_Conditions takes nothing returns boolean
    if ( not ( IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source)) == true ) ) then
        return false
    endif
    if ( not ( udg_PDD_damageType == udg_PDD_PHYSICAL ) ) then
        return false
    endif
    if ( not ( GetUnitTypeId(udg_PDD_source) == 'N00C' ) ) then
        return false
    endif
    return true
endfunction

function Trig_AA_PDD_Actions takes nothing returns nothing
    local unit c = udg_PDD_source
    local unit d
    local location p = GetUnitLoc(udg_PDD_target)
    local integer i = GetUnitLevel(c)
    local real r = 0.3 * GetHeroAgi(udg_PDD_source, true) + 0.6 * GetHeroInt(udg_PDD_source, true)
    local texttag t 
    if ( GetUnitAbilityLevel( c, 'A06G' ) == 4 )then
        set udg_PDD_amount = ( udg_PDD_amount + r )
        call FadingText( ( I2S(R2I(udg_PDD_amount)) + "!" ), udg_PDD_target, 15, 60, 80, 80, 0 )
        call SetUnitAbilityLevel( c, 'A06G', 1 )
        set d = CreateUnitAtLoc( GetOwningPlayer(c), 'h000',  p, 0.00 )
        call UnitAddAbility( d, 'A09C')
        call SetUnitAbilityLevel(d, 'A09C', i)
        call IssueTargetOrder( d, "bloodlust", c )
    else
        call IncUnitAbilityLevel( c, 'A06G' )
    endif
    set c = null
    set d = null
    call RemoveLocation (p)
endfunction

function Trig_AD_PDD_Conditions takes nothing returns boolean
    local boolean a = GetUnitAbilityLevel(udg_PDD_target, 'B03R') > 0
    local boolean b = IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source))
    local boolean c = GetUnitTypeId(udg_PDD_target) == 'N00H'
    //local boolean d = IsUnitType(udg_PDD_source, UNIT_TYPE_RANGED_ATTACKER)
    return ( a and b and c )
endfunction

function Trig_AD_PDD_Actions takes nothing returns nothing
    local real rt = 0.08 * GetUnitAbilityLevel(udg_PDD_target, 'A0D7')
    local real r = (0.1 + rt + 0.001 * GetHeroStr(udg_PDD_target, true))* udg_PDD_amount
    set udg_PDD_amount = udg_PDD_amount - r
    if udg_PDD_amount > 5 then 
        call FadingText( "-" + ( I2S(R2I(r)) ), udg_PDD_target, 10.00, 80.00, 80.00, 80, 0 )
    endif
endfunction

function Trig_AR_PDD_Conditions takes nothing returns boolean
    local boolean a = GetUnitAbilityLevel(udg_PDD_target, 'B02D') > 0
    if ( not ( IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source)) == true ) ) then
        return false
    endif
    if ( not ( udg_PDD_damageType == udg_PDD_PHYSICAL ) ) then
        return false
    endif
    if ( not ( GetUnitTypeId(udg_PDD_source) == 'N006' ) ) then
        return false
    endif
    if ( not ( GetRandomReal(0,100) < 21 or a ) ) then
        return false
    endif
    return true
endfunction

function Trig_AR_PDD_Actions takes nothing returns nothing
    local unit d
    local unit u
    local location p = GetUnitLoc(udg_PDD_target)
    local group g = GetUnitsInRangeOfLocMatching(400, p, Condition(function Trig_PDD_Filter))
    local real rq = 0.4 * GetHeroAgi(udg_PDD_source, true) + 40 * GetUnitAbilityLevel(udg_PDD_source, 'A07G')
    local real xe = 0.6 + (0.2 * GetUnitAbilityLevel(udg_PDD_source, 'A07X'))
    local real r = (xe * GetHeroAgi(udg_PDD_source, true))
    if GetUnitAbilityLevel(udg_PDD_target, 'B02D') > 0 then
        set r = r + rq + GetHeroInt(udg_PDD_source, true)
        set d = CreateUnitAtLoc( GetOwningPlayer(udg_PDD_source), 'h026', p, 0 )
        loop
            set u = FirstOfGroup(g)
            exitwhen u == null
            if GetUnitAbilityLevel( u , 'B02D' ) > 0 then
                call UnitDamageTargetPDD( udg_PDD_source, u, 0.4 * r, 1 )
            endif
            call GroupRemoveUnit( g, u )
        endloop
        call UnitRemoveBuffBJ( 'B02D', udg_PDD_target )
    endif
    set udg_PDD_amount = ( udg_PDD_amount + r )
    set d = CreateUnitAtLoc( GetOwningPlayer(udg_PDD_source), 'h00C', p, 0 )
    call FadingText( ( I2S(R2I(udg_PDD_amount)) + "!" ), udg_PDD_target, 12.00, 60.00, 60.00, 100, 0 )
    call RemoveLocation (p)
endfunction

function Trig_BM_PDD_Conditions takes nothing returns boolean
    if ( not ( IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source)) == true ) ) then
        return false
    endif
    if ( not ( GetUnitTypeId(udg_PDD_source) == 'N015' ) ) then
        return false
    endif
    if ( not ( udg_PDD_damageType == udg_PDD_PHYSICAL ) ) then
        return false
    endif
    if ( ( IsUnitIllusion(udg_PDD_source) ) ) then
        return false
    endif
    return udg_BM_boolean
endfunction

function Trig_BM_PDD_Actions takes nothing returns nothing
    local integer i = 20 + R2I(GetHeroInt(udg_PDD_source, true) * 0.28)
    local location pc = GetUnitLoc(udg_PDD_source)
    local location pu = GetUnitLoc(udg_PDD_target)
    local real angle = AngleBetweenPoints(pc,pu)
    local location pt = PolarProjectionBJ(pu, 100, angle)
    local unit c = udg_PDD_source
    local unit d = CreateUnitAtLoc( GetOwningPlayer(c), 'h01Y', pc, bj_UNIT_FACING )
    call UnitAddAbility(d, 'A071')
    call SetUnitUserData( d, i )
    call IssuePointOrderLoc( d, "carrionswarm", pu )
    call FadingText( I2S((i * 4)) + "!", udg_PDD_source, 14.00, 80, 28, 28, 0 )
    set udg_BM_boolean = false
    set c = null
    set d = null
    call RemoveLocation (pc)
    call RemoveLocation (pu)
endfunction

function Trig_BO_PDD_Conditions takes nothing returns boolean
    if ( not ( IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source)) == true ) ) then
        return false
    endif
    if ( not ( udg_PDD_damageType == udg_PDD_PHYSICAL ) ) then
        return false
    endif
    if ( not ( GetUnitTypeId(udg_PDD_source) == 'N010' ) ) then
        return false
    endif
    return true
endfunction

function Trig_BO_PDD_Actions takes nothing returns nothing
    local unit c = udg_PDD_source
    local unit d
    local unit s
    local real dur = 6 + 0.08 * GetHeroLevel(udg_PDD_source)
    local location p = GetUnitLoc(udg_PDD_target)
    //local integer i = 1
    local group g
    local real r = 0
    local real rq = 0.08 * GetUnitMaxLife(udg_PDD_target) + 70 * GetUnitAbilityLevel(udg_PDD_source, 'A09J')
    local real rw = 0.22 + 0.07 * GetUnitAbilityLevel(udg_PDD_source, 'A0BN')
    local real rr = (20 + 56 * GetUnitAbilityLevel(udg_PDD_source, 'A0BM')) + 2 * GetHeroLevel(udg_PDD_source)
    local boolean ra = GetUnitManaPercent(udg_PDD_source) > 7.5
    local boolean rb = GetUnitAbilityLevel(udg_PDD_source, 'A0BM') > 0
    //passive
    set s = CreateUnitAtLoc(GetOwningPlayer(c), 'h01O', p,0)
    call SetUnitLife(s, dur)
    set udg_BO_stacks = udg_BO_stacks + 1
    if udg_BO_stacks > 8 then
        call SetUnitAbilityLevel(c, 'A07D', 8)
    else 
        call SetUnitAbilityLevel(c, 'A07D', udg_BO_stacks)
    endif
    // r onhit
    if udg_Blackblood_bool and rb then
        set r = r + rr
        //call SetUnitLife(udg_PDD_source, GetUnitLife(udg_PDD_source) - 0.7 * r)
        call SetUnitManaBJ(udg_PDD_source, GetUnitState(udg_PDD_source, UNIT_STATE_MANA) - 0.7 * r )
        call FadingText( "+" + I2S(R2I(r)), udg_PDD_target, 15.00, 70, 70, 70, 0 ) 
    endif
    // q bash
    if GetUnitAbilityLevel(udg_PDD_target, 'B038') > 0 then
        set r = r + rq
        set d = CreateUnitAtLoc( GetOwningPlayer(udg_PDD_source), 'h004', p, 0 )
        call UnitAddAbility( d, 'A05E' )
        call IssueTargetOrder( d, "firebolt", udg_PDD_target )
        call UnitRemoveAbility( udg_PDD_target, 'B038' )
        set d = null
    endif
    set udg_PDD_amount = udg_PDD_amount + r
    // w lifesteal
    if GetUnitAbilityLevel(udg_PDD_target, 'B054') > 0 then
        call SetUnitLife(udg_PDD_source, GetUnitLife(udg_PDD_source) + rw * udg_PDD_amount)
    endif
    //call DisplayTextToForce( GetPlayersAll(), R2S(dur) )
    call RemoveLocation (p)
endfunction

function Trig_BO_PDD_2_Conditions takes nothing returns boolean
    local boolean a = not(udg_Blackblood_bool)
    local boolean b = IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source))
    local boolean c = GetUnitTypeId(udg_PDD_target) == 'N010'
    local boolean d = GetUnitManaPercent(udg_PDD_target) < 92.5
    local boolean e = GetUnitAbilityLevel(udg_PDD_target, 'A0BM') > 0
    return (a and b and c and d and e)
endfunction

function Trig_BO_PDD_2_Actions takes nothing returns nothing
    //local location p = GetUnitLoc(udg_PDD_target)
    local real r = udg_PDD_amount * (0.15 + 0.15 * GetUnitAbilityLevel(udg_PDD_target, 'A0BM')) 
    call SetUnitManaBJ( udg_PDD_target, ( GetUnitState(udg_PDD_target, UNIT_STATE_MANA) + 0.7 * r ))
    call FadingText( "-" +(I2S(R2I(r)) ), udg_PDD_target, 10.00, 80, 80, 80, 0 )
    set udg_PDD_amount = udg_PDD_amount - r 
    //call RemoveLocation(p)
endfunction

function Trig_BT_PDD_Conditions takes nothing returns boolean
    local real d = 27 * GetUnitAbilityLevel(udg_PDD_target,'B03P')
    local boolean a = GetRandomReal(0,100) < (0.9*GetHeroLevel(udg_PDD_source) + 27 + d )
    if ( not ( IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source)) == true ) ) then
        return false
    endif
    if ( not ( GetUnitTypeId(udg_PDD_source) == 'N00K' ) ) then
        return false
    endif
    if ( not ( udg_PDD_damageType != udg_PDD_CODE) ) then
        return false
    endif
    return a
endfunction

function Trig_BT_PDD_Actions takes nothing returns nothing
    local location p = GetUnitLoc(udg_PDD_target)
    call CreateUnitAtLoc(GetOwningPlayer(udg_PDD_source),'h00K',p,0)
    call RemoveLocation(p)
endfunction

function Trig_CS_PDD_Conditions takes nothing returns boolean
    if ( not ( IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source)) == true ) ) then
        return false
    endif
    if ( not ( udg_PDD_damageType == udg_PDD_PHYSICAL ) ) then
        return false
    endif
    if ( not ( GetUnitTypeId(udg_PDD_source) == 'N01A' ) ) then
        return false
    endif
    if ( not ( GetUnitPercentLife(udg_PDD_target) < 60 ) ) then
        return false
    endif
    return true
endfunction

function Trig_CS_PDD_Actions takes nothing returns nothing
    local integer i = GetHeroLevel(udg_PDD_source)
    local unit d 
    local location pu = GetUnitLoc(udg_PDD_target)
    set d = CreateUnitAtLoc(GetOwningPlayer(udg_PDD_source), 'h000', pu, bj_UNIT_FACING )
    call UnitAddAbility(d, 'A0AV')
    call SetUnitAbilityLevel( d, 'A0AV', i)
    call IssueTargetOrder( d, "soulburn", udg_PDD_target )
    call CreateUnitAtLoc( GetOwningPlayer(udg_PDD_source), 'h002', pu, bj_UNIT_FACING )
    call RemoveLocation (pu)
endfunction

function Trig_CS_PDD_2_Conditions takes nothing returns boolean
    if ( not ( IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source)) == true ) ) then
        return false
    endif
    if ( not ( GetUnitTypeId(udg_PDD_target) == 'N01A' ) ) then
        return false
    endif
    if ( not ( udg_PDD_damageType == udg_PDD_SPELL ) ) then
        return false
    endif
    if ( not ( GetUnitAbilityLevel(udg_PDD_target, 'B04K') > 0 ) ) then
        return false
    endif
    return true
endfunction

function Trig_CS_PDD_2_Actions takes nothing returns nothing
    local texttag t
    local real r = (0.1 + 0.1 * I2R(GetUnitAbilityLevel(udg_PDD_target, 'A0AW')))* udg_PDD_amount
    set udg_PDD_amount = udg_PDD_amount - r 
    call FadingText( "-" +(I2S(R2I(r)) ), udg_PDD_target, 10.00, 100, 90, 90, 0 )
endfunction

function Trig_DN_PDD_Conditions takes nothing returns boolean
    if ( not ( IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source)) == true ) ) then
        return false
    endif
    if ( not ( udg_PDD_damageType == udg_PDD_PHYSICAL ) ) then
        return false
    endif
    if ( not ( GetUnitTypeId(udg_PDD_source) == 'N00A' ) ) then
        return false
    endif
    return true
endfunction

function Trig_DN_PDD_Actions takes nothing returns nothing
    local boolean back1 = GetUnitAbilityLevel(udg_PDD_source, 'A01S') > 0 
    local boolean back2 = Backstab(udg_PDD_source, udg_PDD_target) //check angle 
    local boolean back = back1 and back2
    local location pc = GetUnitLoc(udg_PDD_source)
    local location pu 
    local unit d
    local real tm = UnitInventoryCount(udg_PDD_source) * 20 
    local real base = GetRandomReal(0,8) + tm + 2 * GetHeroLevel(udg_PDD_source) + GetHeroAgi(udg_PDD_source,true)
    local real xe = 0.08 * GetUnitAbilityLevel(udg_PDD_source, 'A01S') 
    local real x = 1
    local real r
    local unit u
    local string s = "!"
    set udg_PDD_amount = 0 
    //setting target
    if udg_Tag_target != null then 
        set u = udg_Tag_target
    else 
        set u = udg_PDD_target
    endif
    //if target is shadow melted or tagged, it is backstabbed if dante has skilled it
    if GetUnitAbilityLevel(u, 'B023') > 0  or u == udg_Tag_target then
        set back = GetUnitAbilityLevel(udg_PDD_source, 'A01S') > 0 
    endif
    if back then
        set x = x + xe
        set s = "!!"
    endif
    set r = 0.8 * base * x
    call UnitDamageTargetPDD (udg_PDD_source, u, r, 0)
    call FadingText( I2S(R2I(r)) + s, u, 13.00, 64, 80, 64, 0 ) 
    set d = null
    set u = null
    call RemoveLocation (pc)
    call RemoveLocation (pu)
endfunction

function Trig_DC_PDD_Conditions takes nothing returns boolean
    if ( not ( IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source)) == true ) ) then
       return false
    endif
    if ( not ( udg_PDD_damageType == udg_PDD_PHYSICAL ) ) then
        return false
    endif
    if ( not ( IsUnitType(udg_PDD_target, UNIT_TYPE_HERO) == true ) ) then
        return false
    endif
    if ( not ( GetUnitTypeId(udg_PDD_source) == 'N003' ) ) then
        return false
    endif
    return true
endfunction

function Trig_DC_PDD_Actions takes nothing returns nothing
    local location p = GetUnitLoc(udg_PDD_target)
    local unit fx
    local real r
    local real r1 = GetUnitLife(udg_PDD_source) - GetUnitLife(udg_PDD_target)
    local real m = 0.09
    local real xw = 0.3 + 0.2 * GetUnitAbilityLevel(udg_PDD_source, 'A0AN')
    if r1 > 3000 then
        set r1 = 3000
    endif
    if r1 < 0 then
        set r1 = 0
    endif
    if (GetUnitAbilityLevel(udg_PDD_target, 'B02L') > 0) then
        set m = m * 1.3
    endif
    set r = m * r1
    set udg_PDD_amount = udg_PDD_amount + r
    if (GetUnitAbilityLevel(udg_PDD_source, 'B04F') > 0) then
        call SetUnitLife(udg_PDD_source, GetUnitLife(udg_PDD_source) + xw * r)
    endif
    if r > 0 then
        call FadingText( "+" + I2S(R2I(r)), udg_PDD_source, 13.00, 63, 63, 50, 0 )
    //else
        //call FadingText( "+" + I2S(R2I(r)), udg_PDD_source, 11.00, 37, 37, 50, 0 )
    endif
    set fx = CreateUnitAtLoc( GetOwningPlayer(udg_PDD_source), 'h002', p, bj_UNIT_FACING )
    set fx = null
    call RemoveLocation (p)
endfunction

function Trig_DC_PDD_2_Conditions takes nothing returns boolean
    if ( not ( IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source)) == true ) ) then
       return false
    endif
    if ( not ( udg_PDD_damageType == udg_PDD_PHYSICAL ) ) then
        return false
    endif
    if ( not ( GetUnitAbilityLevel( udg_PDD_target, 'A0A2') > 0 ) ) then
        return false
    endif
    if ( not ( GetUnitTypeId(udg_PDD_target) == 'N003' ) ) then
        return false
    endif
    return true
endfunction

function Trig_DC_PDD_2_Actions takes nothing returns nothing
    local real r =  18 * I2R(GetUnitAbilityLevel(udg_PDD_target,'A0A2')) + 2 * GetUnitLevel(udg_PDD_target) - 10
    if r < udg_PDD_amount then
        call FadingText( "-" +(I2S(R2I(r)) ), udg_PDD_target, 10.00, 100, 100, 100, 0 )
        set udg_PDD_amount = udg_PDD_amount - r 
    else 
        call FadingText( "-" +(I2S(R2I(udg_PDD_amount)) ), udg_PDD_target, 10.00, 100, 100, 100, 0 )
        set udg_PDD_amount = 0
    endif
endfunction

function Trig_EM_PDD_Conditions takes nothing returns boolean
    if ( not ( IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source)) == true ) ) then
        return false
    endif
    if ( not ( udg_PDD_damageType == udg_PDD_PHYSICAL ) ) then
        return false
    endif
    if ( not ( GetUnitTypeId(udg_PDD_source) == 'N00J' ) ) then
        return false
    endif
    return true
endfunction

function Trig_EM_PDD_Actions takes nothing returns nothing
    local unit c = udg_PDD_source
    call UnitCharge(c, 1)
    set udg_LS_bool = true
endfunction

function Trig_FS_PDD_Conditions takes nothing returns boolean
    if ( not ( IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source)) == true ) ) then
        return false
    endif
    if ( not ( udg_PDD_damageType == udg_PDD_SPELL ) ) then
        return false
    endif
    if ( not ( GetUnitTypeId(udg_PDD_source) == 'N01G' ) ) then
        return false
    endif
    return true
endfunction

function Trig_FS_PDD_Actions takes nothing returns nothing
    local unit u = udg_PDD_target
    local real r = (0.15 + GetUnitAbilityLevel(u, 'A08R')* 0.015) * GetHeroInt(udg_PDD_source, true)
    local location p = GetUnitLoc(u)
    local unit d
    local texttag t
    //local integer i = 5
    call UnitFloral(udg_PDD_source,u,5) 
    if ( GetUnitAbilityLevel(u, 'A08R') > 15 ) then
        set udg_PDD_amount = udg_PDD_amount + r
        set d = CreateUnitAtLoc( GetOwningPlayer(udg_PDD_source), 'h017', p, 0 )
        call FadingText( I2S(R2I(udg_PDD_amount))+ "!", u, 15.00, 10.00, 100.00, 50.00, 0 )   
    endif
    //call DisplayTextToForce(bj_FORCE_ALL_PLAYERS,I2S(stack))
    call RemoveLocation (p)
    set u = null
    set d = null
endfunction

function Trig_FMD_PDD_Conditions takes nothing returns boolean
    //local integer i = GetHeroLevel(udg_PDD_source)
    if ( not ( IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source)) == true ) ) then
        return false
    endif
    if ( not ( udg_PDD_damageType == udg_PDD_PHYSICAL ) ) then
        return false
    endif
    if ( not ( GetUnitTypeId(udg_PDD_source) == 'N00O' ) ) then
        return false
    endif
    return true
endfunction

function Trig_FMD_PDD_Actions takes nothing returns nothing
    //local unit c = udg_PDD_source
    //local real r = 6 + GetHeroLevel(udg_PDD_source)*0.72
    //local boolean a = ((udg_PDD_amount)* 0.15 > r) 
    local real v = 0.4 * GetUnitAbilityLevel(udg_PDD_source, 'A060')
    local real rr = 1 + GetUnitAbilityLevel(udg_PDD_source, 'B01D') * v
    local real tm = UnitInventoryCount(udg_PDD_source) * 7
    local real v1 = 5 + GetHeroLevel(udg_PDD_source)
    local real v2 = 90 + GetHeroAgi(udg_PDD_source, true)
    //local real rx = 0.18 * (2 + GetUnitAbilityLevel(udg_PDD_source, 'A060')) 
    //
    set udg_SF_caster = udg_PDD_source
    //set udg_FMD_multi = 7 + (24 * udg_SF_int)/(70 - 2 * udg_SF_int)
    //call DisplayTextToForce( GetPlayersAll(), "aspd scaling: " + R2S(udg_FMD_multi) )
    set udg_SF_int = 12
    set udg_SF_point = GetUnitLoc(udg_PDD_target)
    if IsTriggerEnabled(gg_trg_SF_2) == false then // GetUnitManaPercent(udg_PDD_source) > 30 then
        call EnableTrigger( gg_trg_SF_2 )
    endif
    //set udg_FMD_multi = (0.003 * udg_FMD_multi * (90 + GetHeroAgi(udg_PDD_source, true))) + tm 
    set udg_FMD_multi = (0.01 * rr * v1 * v2) + tm 
    //call DisplayTextToForce( GetPlayersAll(), "total damage: " + R2S(udg_FMD_multi) )
    set udg_PDD_amount = 0
endfunction

function Trig_FMD_PDD_2_Conditions takes nothing returns boolean
    if ( not ( IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source)) == true ) ) then
        return false
    endif
    if ( not ( udg_PDD_damageType == udg_PDD_PHYSICAL ) ) then
        return false
    endif
    if ( not ( GetUnitTypeId(udg_PDD_source) == 'h01N' ) ) then
        return false
    endif
    return true
endfunction

function Trig_FMD_PDD_2_Actions takes nothing returns nothing
    local real x = 0.075
    local real r = udg_PDD_amount
    if IsUnitType (udg_PDD_target, UNIT_TYPE_HERO) then 
        set x = 0.1
    endif
    set r = r * x * udg_FMD_multi
    ///call UnitDamageTargetPDD (udg_SF_caster, udg_PDD_target, r, 0)
    set udg_PDD_amount = r
    call RemoveUnit (udg_PDD_source)
    //call DisplayTextToForce( GetPlayersAll(), R2S(udg_PDD_amount) )
endfunction

function Trig_GS_PDD_Conditions takes nothing returns boolean
    if ( not ( IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source)) == true ) ) then
        return false
    endif
    if ( not ( udg_PDD_damageType == udg_PDD_PHYSICAL ) ) then
        return false
    endif
    if ( not ( GetUnitTypeId(udg_PDD_source) == 'N018' ) ) then
        return false
    endif
    return true
endfunction

function Trig_GS_PDD_Actions takes nothing returns nothing
    local real r =  0.5 + 0.01 * GetHeroLevel(udg_PDD_source)
    local boolean b = GetUnitAbilityLevel(udg_PDD_source, 'B05H') > 0
    local integer vw = 1 + GetUnitAbilityLevel(udg_PDD_source, 'A0C8') * 5 + GetHeroLevel(udg_PDD_source)
    local unit d 
    local location pu = GetUnitLoc(udg_PDD_target)
    local real xw = 0.05 + 0.001 * GetHeroAgi(udg_PDD_source, true)
    if IsTriggerEnabled(gg_trg_MS_2) then
        //if multishot is active do this
        set udg_PDD_amount = ( udg_PDD_amount * r )
    endif
    if (b) then
        //if cooling orb is active do this
        set d = CreateUnitAtLoc(GetOwningPlayer(udg_PDD_source), 'h000', pu, bj_UNIT_FACING )
        call UnitAddAbility(d, 'A0C9')
        call SetUnitAbilityLevel( d, 'A0C9', vw)
        call IssueTargetOrder( d, "slow", udg_PDD_target )
        call SetUnitLife(udg_PDD_source, GetUnitLife(udg_PDD_source) + (xw * udg_PDD_amount))
    endif
    call RemoveLocation(pu)
    //call DisplayTextToForce( GetPlayersAll(), R2S(udg_PDD_amount) )
endfunction

function Trig_GW_PDD_Conditions takes nothing returns boolean
    local boolean a = udg_PDD_damageType == udg_PDD_SPELL
    local boolean b = GetUnitAbilityLevel(udg_PDD_target, 'B03I') > 0  
    if ( not ( IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source))) ) then
        return false
    endif
    if ( not ( GetUnitTypeId(udg_PDD_target) == 'N017' ) ) then
        return false
    endif
    return (a or b)
endfunction

function Trig_GW_PDD_Actions takes nothing returns nothing
    local real x = 0 
    local real r = 0
    if udg_PDD_damageType == udg_PDD_SPELL then 
        set x = x + 0.01 * (10 + GetHeroLevel(udg_PDD_target))
    endif
    if ( GetUnitAbilityLevel(udg_PDD_target, 'B03I') > 0 ) then
        set x = x + 0.07 * GetUnitAbilityLevel(udg_PDD_target, 'A08C')
    endif
    //
    set r = x * udg_PDD_amount
    if udg_MF_real < r and GetUnitAbilityLevel(udg_PDD_target, 'B03I') > 0 then
        set r = udg_MF_real
        set udg_MF_real = 0
        call UnitRemoveAbility(udg_PDD_target, 'B03I')
    endif
    if r > 5 then
        call FadingText( I2S(R2I(udg_MF_real)) + "(-" + I2S(R2I(r)) + ")", udg_PDD_target, 11.00, 70, 70, 70, 0 )
    endif
    set udg_PDD_amount = udg_PDD_amount - r 

endfunction

function Trig_HO_PDD_Conditions takes nothing returns boolean
    if ( not ( IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source)) == true ) ) then
        return false
    endif
    if ( not ( udg_PDD_damageType == udg_PDD_SPELL ) ) then
        return false
    endif
    if ( not ( GetUnitTypeId(udg_PDD_source) == 'N00I' ) ) then
        return false
    endif
    return true
endfunction

function Trig_HO_PDD_Actions takes nothing returns nothing
    local real r =  0.4 + 0.01 * GetHeroInt(udg_PDD_source, true)
    //local real r2 = 1 + GetUnitMissingPercentLife(udg_PDD_target)/200
    set udg_PDD_amount = ( udg_PDD_amount * r )
endfunction

function Trig_HV_PDD_Conditions takes nothing returns boolean
    local integer i = GetHeroAgi(udg_PDD_target, true)
    local boolean a = GetRandomInt(1,700) < i
    local boolean b = IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source))
    local boolean c = GetUnitTypeId(udg_PDD_target) == 'N002'
    return (a and b and c)
endfunction

function Trig_HV_PDD_Actions takes nothing returns nothing
    //local location p = GetUnitLoc(udg_PDD_target)
    local real r = udg_PDD_amount
    if r > 100 then
       call FadingText( "!", udg_PDD_target, 13.00, 98.00, 98.00, 0.00, 0 ) 
    endif
    set udg_PDD_amount = 0
    //call RemoveLocation(p)
endfunction

function Trig_HQ_PDD_Conditions takes nothing returns boolean
    local boolean a = GetUnitAbilityLevel(udg_PDD_target,'B01P') > 0
    local boolean b = GetUnitAbilityLevel(udg_PDD_target,'B01X') > 0
    local boolean c = GetUnitAbilityLevel(udg_PDD_target,'B039') > 0
    if ( not ( IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source)) == true ) ) then
        return false
    endif
    if ( not ( udg_PDD_damageType == udg_PDD_PHYSICAL ) ) then
        return false
    endif
    if ( not ( GetUnitTypeId(udg_PDD_source) == 'N019' ) ) then
        return false
    endif
    if ( not ( GetUnitAbilityLevel(udg_PDD_source,'A06F') > 0 ) ) then
        return false
    endif
    if ( not ( a or b or c ) ) then
        return false
    endif
    return true
endfunction

function Trig_HQ_PDD_Actions takes nothing returns nothing
    local unit u = udg_PDD_target
    local unit c = udg_PDD_source
    local unit d
    local location p = GetUnitLoc(u)
    local integer i
    set i = GetUnitAbilityLevel(c,'A06F')
    set d = CreateUnitAtLoc( GetOwningPlayer(c), 'h000',  p, bj_UNIT_FACING )
    call UnitAddAbility( d, 'A06E' )
    call SetUnitAbilityLevel( d, 'A06E', i )
    call IssueTargetOrder( d, "acidbomb", u )
    set u = null
    set c = null
    set d = null
    call RemoveLocation (p)
endfunction

function Trig_IN_PDD_Conditions takes nothing returns boolean
    if ( not ( IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source)) == true ) ) then
        return false
    endif
    if ( not ( udg_PDD_damageType == udg_PDD_PHYSICAL ) ) then
        return false
    endif
    if ( not ( GetUnitTypeId(udg_PDD_source) == 'N00N' ) ) then
        return false
    endif
    return true
endfunction

function Trig_IN_PDD_Actions takes nothing returns nothing
    local unit u
    local unit d
    local boolean b = GetUnitAbilityLevel(udg_PDD_source,'B022') > 0
    local location p = GetUnitLoc(udg_PDD_target)
    //local group g = GetUnitsInRangeOfLocMatching(240, p, Condition(function Trig_PDD_Filter))
    //local real r = (GetHeroLevel(udg_PDD_source) * 1 + GetHeroAgi(udg_PDD_source,true))
    local real xp = 1
    local real day = 1.05 + 0.03 * GetHeroLevel(udg_PDD_source)
    local real rr = 0
    local real vq = 0.12 * GetUnitAbilityLevel(udg_PDD_source, 'A04F')
    local real vr = 0.12 + 0.12 * GetUnitAbilityLevel(udg_PDD_source, 'A023')
    local real dz = 0.5 + 0.02 * GetHeroLevel(udg_PDD_source)
    local real z = 9
    local string s = "?"
    local real colour = 99
    if Daytime() or b then
        set xp = day + vq
        set s = "!"
        set z = 12
        set colour = 90
    endif
    if b then
        set s = "!!"
        set rr = vr * GetHeroAgi(udg_PDD_source, true)
        set colour = 72
        set d = CreateUnitAtLoc( GetOwningPlayer(udg_PDD_source), 'h01V', p, 0 )
        call SetUnitScale( d, dz, dz, dz )
        call RemoveLocation (p)
        set d = null
    endif
    set udg_PDD_amount = (udg_PDD_amount + rr) * xp
    if IsUnitType(udg_PDD_target, UNIT_TYPE_HERO) then
        call FadingText( I2S(R2I(udg_PDD_amount)) + s, udg_PDD_target, z + udg_PDD_amount * 0.001, 99, colour, colour, 0 )
    endif
    //call DisplayTextToForce( GetPlayersAll(), R2S(r) )
endfunction

function Trig_LM_PDD_Conditions takes nothing returns boolean
    //local boolean a = GetUnitManaPercent(udg_PDD_target) > 22
    local boolean b = IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source))
    local boolean c = GetUnitTypeId(udg_PDD_target) == 'N005'
    local boolean d = GetUnitAbilityLevel(udg_PDD_target,'A0AZ') > 0
    return (d and b and c)
endfunction

function Trig_LM_PDD_Actions takes nothing returns nothing
    //local location p = GetUnitLoc(udg_PDD_target)
    local real x = 2.2 - 0.2 * GetUnitAbilityLevel(udg_PDD_target,'A0AZ')
    local real n = GetUnitManaPercent(udg_PDD_target) * 0.01
    local real r = (0.3 + 0.1 * GetUnitAbilityLevel(udg_PDD_target,'A0AZ')) * n * udg_PDD_amount
    call SetUnitManaBJ( udg_PDD_target, ( GetUnitState(udg_PDD_target, UNIT_STATE_MANA) - r * x ))
    //call DisplayTextToForce( GetPlayersAll(), R2S(udg_PDD_amount/2.2) )
    set udg_PDD_amount = udg_PDD_amount - r 
    if udg_PDD_amount > 5 then
        call FadingText( "-" + ( I2S(R2I(r)) ), udg_PDD_target, 10.00, 80.00, 80.00, 80, 0 )
    endif
    //call RemoveLocation(p)
endfunction

function Trig_MA_PDD_Conditions takes nothing returns boolean
    local boolean b = udg_PDD_damageType == udg_PDD_SPELL
    local boolean c = udg_PDD_damageType == udg_PDD_PHYSICAL
    if ( not ( IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source)) == true ) ) then
       return false
    endif
    if ( not ( b or c ) ) then
        return false
    endif
    if ( not ( GetUnitTypeId(udg_PDD_source) == 'N01E' ) ) then
        return false
    endif
    return true
endfunction

function Trig_MA_PDD_Actions takes nothing returns nothing
    local boolean hero = IsUnitType(udg_PDD_target, UNIT_TYPE_HERO)
    local unit d
    local location p = GetUnitLoc(udg_PDD_target)
    local real rp = (0.105 + 0.005 * GetHeroLevel(udg_PDD_source)) * GetUnitMaxLife(udg_PDD_target)
    local real ri = 0.25 + 0.03 * GetHeroLevel(udg_PDD_source) * GetHeroInt(udg_PDD_source, true)
    local real vi = 2 * GetHeroInt(udg_PDD_source,true) + GetHeroBonusInt(udg_PDD_source)
    local real rq = 0.05 + 0.03 * GetUnitAbilityLevel(udg_PDD_source, 'A0CL')
    local real rw = 0.05 * GetUnitAbilityLevel(udg_PDD_source, 'A0CT')
    local real re = 0.25 + 0.05 * GetUnitAbilityLevel(udg_PDD_source, 'A01B')
    local real r = 0
    local real rx = 1
    local real z = 11
    if udg_PDD_damageType == udg_PDD_PHYSICAL then
        //talons of malice
        if ( GetUnitAbilityLevel(udg_PDD_source, 'B05P') > 0 ) then
            //call DisplayTextToForce( GetPlayersAll(), "talons empower!" )
            set r = r + rq * vi
            set z = z + 2
            call SetUnitLife(udg_PDD_source, GetUnitLife(udg_PDD_source) + rq*vi)
            if udg_TM_int > 1  then
                set udg_TM_int = udg_TM_int - 1
            else 
                call UnitRemoveAbility(udg_PDD_source, 'B05P')
            endif
            call CreateUnitAtLoc( GetOwningPlayer(udg_PDD_source), 'h02D', p, bj_UNIT_FACING )
        endif
        //target is marked
        if ( GetUnitAbilityLevel(udg_PDD_target, 'B05Q') > 0 ) then
            //call DisplayTextToForce( GetPlayersAll(), "mark empower!" )
            set rx = 1 + rw
            set z = z + 1
        endif
    else
        //baleful warning
        if (GetUnitAbilityLevel(udg_PDD_target, 'B05Q') == 0 and hero) then
            //cast ff on target
            set d = CreateUnitAtLoc( GetOwningPlayer(udg_PDD_source), 'h000',  p, bj_UNIT_FACING )
            call UnitAddAbility( d, 'A0CM' )
            //call SetUnitAbilityLevel( d, 'A06E', i )
            call IssueTargetOrder( d, "faeriefire", udg_PDD_target )
            call CreateUnitAtLoc( GetOwningPlayer(udg_PDD_source), 'h004', p, bj_UNIT_FACING )
            //call DisplayTextToForce( GetPlayersAll(), "passive empower!" )
            set r = r + rp + ri
            set z = z + 2
        endif
    endif
    //umbral veil
    if GetUnitAbilityLevel(udg_PDD_source, 'B046') > 0 then
        call UnitRemoveAbility(udg_PDD_source, 'B046')
        //call DisplayTextToForce( GetPlayersAll(), "umbral veil empower!" )
        set r = r + re * vi
        set z = z + 1
    endif
    if r > 0 or rx > 1 then
        set udg_PDD_amount = (udg_PDD_amount + r) * rx
        call FadingText( I2S(R2I(udg_PDD_amount)) + "!!" , udg_PDD_target, z, 50, 70, 50, 0 )
    endif
    //call DisplayTextToForce( GetPlayersAll(), R2S(udg_PDD_amount) )
    call RemoveLocation (p)
endfunction

function Trig_NP_PDD_Conditions takes nothing returns boolean
    if ( not ( IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source)) == true ) ) then
        return false
    endif
    if ( not ( udg_PDD_damageType == udg_PDD_PHYSICAL ) ) then
        return false
    endif
    if ( not ( GetUnitTypeId(udg_PDD_source) == 'N00M' ) ) then
        return false
    endif
    if ( IsUnitType(udg_PDD_target, UNIT_TYPE_STRUCTURE) ) then
        return false
    endif
    return true
endfunction

function Trig_NP_PDD_Actions takes nothing returns nothing
    local real r = 0.09 * GetHeroAgi(udg_PDD_source,true)
    local real r2 = (25 + GetHeroLevel(udg_PDD_source))* 0.005
    local real rc = 0.15 + 0.05 * GetUnitAbilityLevel(udg_PDD_source, 'A007')
    local real re = 1 + 0.3 * GetUnitAbilityLevel(udg_PDD_source, 'A03S')
    if rc > GetRandomReal(0,1) and GetUnitAbilityLevel(udg_PDD_source, 'A007') > 0 then
        set udg_PDD_amount = (udg_PDD_amount + r ) * re
        call FadingText( I2S(R2I(udg_PDD_amount)) + "!!" , udg_PDD_target, 13.00, 90, 13, 13, 0 )
    else
        set udg_PDD_amount = udg_PDD_amount + r
    endif
    if IsTriggerEnabled(gg_trg_DO_3) then
        set r2 = r2 * 2
    endif
    //call DisplayTextToForce( GetPlayersAll(), R2S(r2) )
    call SetUnitLife(udg_PDD_source, GetUnitLife(udg_PDD_source) + (r2 * udg_PDD_amount))
    //call FadingText( "+" + I2S(R2I(r2 * udg_PDD_amount)), udg_PDD_source, 13.00, 90, 65, 65, 0 ) 
endfunction

function Trig_PS_PDD_Conditions takes nothing returns boolean
    if ( not ( IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source)) == true ) ) then
        return false
    endif
    //if ( not ( udg_PDD_damageType == udg_PDD_PHYSICAL ) ) then
    //    return false
    //endif
    if ( not ( IsUnitType(udg_PDD_target, UNIT_TYPE_HERO) ) ) then
        return false
    endif   
    if ( not ( GetUnitTypeId(udg_PDD_source) == 'N00W' ) ) then
        return false
    endif
    if ( IsUnitType(udg_PDD_target, UNIT_TYPE_STRUCTURE) ) then
        return false
    endif
    return true
endfunction

function Trig_PS_PDD_Actions takes nothing returns nothing
    local location pu = GetUnitLoc(udg_PDD_target)
    local location pt = GetUnitLoc(udg_PDD_source)
    local integer i = GetUnitAbilityLevel(udg_PDD_source, 'A04Q')
    local real amp = 1
    local real r
    local real x = DistanceBetweenPoints(pu, pt) * 0.00003
    local real v = 6 + (GetHeroLevel(udg_PDD_source))
    local texttag t
    if (GetUnitAbilityLevel(udg_PDD_target, 'B01N') > 0 ) then
        set amp = 1.05 + i * 0.05
    endif
    set r = v * x * amp + 1
    set udg_PDD_amount = ( udg_PDD_amount * r )
    call FadingText(( I2S(R2I(udg_PDD_amount)) + "!!" ), udg_PDD_target, 13.00 + x, 0, 100, 0, 0 )
    call RemoveLocation (pu)
    call RemoveLocation (pt)
endfunction

function Trig_PT_PDD_Conditions takes nothing returns boolean
    if ( not ( IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source)) == true ) ) then
        return false
    endif
    if ( not ( udg_PDD_damageType != udg_PDD_PHYSICAL ) ) then
        return false
    endif
    if ( not ( GetUnitTypeId(udg_PDD_source) == 'N009' ) ) then
        return false
    endif
    if ( not ( IsUnitType(udg_PDD_target, UNIT_TYPE_HERO) == true ) ) then
        return false
    endif
    if ( not ( GetUnitAbilityLevel(udg_PDD_target, 'B04G') > 0 ) ) then
        return false
    endif 
    return true
endfunction

function Trig_PT_PDD_Actions takes nothing returns nothing
    local unit fx
    local location p = GetUnitLoc(udg_PDD_target)
    local real r2 = 1.2 * GetHeroInt(udg_PDD_source, true) + GetHeroLevel(udg_PDD_source)*9
    local real r = ( 120.00 - GetUnitPercentLife(udg_PDD_target) ) * r2 * 0.01
    set udg_PDD_amount = ( udg_PDD_amount + r )
    call UnitRemoveAbility(udg_PDD_target, 'B04G')
    set fx = CreateUnitAtLoc(GetOwningPlayer(udg_PDD_source),'h01A', p, 0)
    call FadingText( ( "+" + I2S(R2I(r)) + "!"), udg_PDD_target, 18.00, 100, 60, 0, 0 )
    call RemoveLocation (p)
endfunction

function Trig_RB_PDD_Conditions takes nothing returns boolean
    if ( not ( IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source)) == true ) ) then
        return false
    endif
    if ( not ( udg_PDD_damageType == udg_PDD_PHYSICAL ) ) then
        return false
    endif
    if ( not ( GetUnitTypeId(udg_PDD_source) == 'H00M' ) ) then
        return false
    endif
    if ( not ( udg_RB_rage > 0 ) ) then
        return false
    endif
    return true
endfunction

function Trig_RB_PDD_Actions takes nothing returns nothing
    local unit fx
    local location p = GetUnitLoc(udg_PDD_target)
    local real rv = GetUnitAbilityLevel(udg_PDD_source, 'A02I')
    local real rx = 1 + GetUnitAbilityLevel(udg_PDD_source, 'B063') * (0.1 + 0.2 * rv)
    local real rp = 0.04 + 0.002 * GetHeroLevel(udg_PDD_source) 
    local real r = udg_RB_rage * rp * rx
    local real z = rp * 20
    set udg_PDD_amount = udg_PDD_amount + r
    if rx > 1 then
        call FadingText( ( "+" + I2S(R2I(r)) ), udg_PDD_source, 13 + 40 * rp, 80.00, 0, 0, 0 )
    else
        call FadingText( ( "+" + I2S(R2I(r)) ), udg_PDD_source, 13 + 20 * rp, 90.00, 0, 0, 0 )
    endif
    //set udg_RB_rage = udg_RB_rage * 0.5
    set udg_RB_combat = 5
    call CreateUnitAtLoc( GetOwningPlayer(udg_PDD_source), 'h002',  p, bj_UNIT_FACING )
    call RemoveLocation (p)
endfunction

function Trig_RB_PDD_2_Conditions takes nothing returns boolean
    return (GetUnitTypeId(udg_PDD_target) == 'H00M') and udg_PDD_amount > 0
endfunction

function Trig_RB_PDD_2_Actions takes nothing returns nothing
    //local real r = 0.2 * udg_PDD_amount
    //local real rv = 0.5 // + 0.01 * GetHeroLevel(udg_PDD_target)
    //set r = rv * udg_PDD_amount
    //set udg_PDD_amount = udg_PDD_amount + r
    //if r > 5 then
    //    call FadingText( ( "+" + I2S(R2I(r)) ), udg_PDD_target, 10, 90.00, 0, 0, 0 )
    //endif
    set udg_RB_combat = 5
    if udg_RB_rage < GetUnitMaxLife(udg_PDD_target) then
        set udg_RB_rage = udg_RB_rage + udg_PDD_amount
    else
        set udg_RB_rage = GetUnitMaxLife(udg_PDD_target)
    endif
    set udg_Aaron = udg_PDD_target
    if ( not IsTriggerEnabled(gg_trg_Rage_Decay) ) then
        call EnableTrigger( gg_trg_Rage_Decay )
    endif
endfunction

function Trig_RH_PDD_Conditions takes nothing returns boolean
    if ( not ( IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source)) == true ) ) then
        return false
    endif
    //if ( not ( udg_PDD_damageType == udg_PDD_PHYSICAL) ) then
    //    return false
    //endif
    if ( not ( GetUnitTypeId(udg_PDD_source) == 'N00V' ) ) then
        return false
    endif
    return true
endfunction

function Trig_RH_PDD_Filter takes nothing returns boolean
    if ( not ( IsUnitType(udg_PDD_target, UNIT_TYPE_HERO) == true ) ) then
        return false
    endif
    //if ( not (GetUnitAbilityLevel(udg_PDD_source,'A08D') > 0 ) ) then
    //    return false
    //endif
    return true
endfunction

function Trig_RH_PDD_Actions takes nothing returns nothing
    local real r = 0.2 * GetHeroInt(udg_PDD_source, true) + 0.3 * GetHeroBonusInt(udg_PDD_source)
    //if ( Trig_RH_PDD_Filter() ) then
    //    set udg_PDD_amount = ( 0.67 * udg_PDD_amount + r )
    //    call FadingText( "+" + I2S(R2I(r)), udg_PDD_target, 12.00, 80, 80, 40, 0 )
    //else
    //    set udg_PDD_amount = ( 0.67 * udg_PDD_amount)
    //endif
    local real v = ( r + GetHeroLevel(udg_PDD_source) ) * 0.01
    if ( Trig_RH_PDD_Filter() ) then
        set udg_PDD_amount = ( ( 0.75 + v ) * udg_PDD_amount )
    else
        set udg_PDD_amount = ( 0.5 * udg_PDD_amount + r)
    endif
endfunction

function Trig_RP_PDD_Conditions takes nothing returns boolean
    local boolean a = udg_PDD_damageType == udg_PDD_SPELL
    local boolean b = udg_PDD_damageType == udg_PDD_PHYSICAL
    local boolean c = GetRandomReal(0,100) < 12
    if ( not ( IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source)) == true ) ) then
        return false
    endif
    if ( not ( IsUnitType(udg_PDD_target, UNIT_TYPE_HERO) == true ) ) then
        return false
    endif
    if ( not ( a or (b and c) ) ) then
        return false
    endif
    if ( not ( GetUnitTypeId(udg_PDD_source) == 'H001' ) ) then
        return false
    endif
    return true
endfunction

function Trig_RP_PDD_Filter takes nothing returns boolean
    local boolean a = GetUnitTypeId(GetFilterUnit()) == 'h00A'
    local boolean b = IsUnitAlly(GetFilterUnit(), GetOwningPlayer(udg_PDD_source))
    return ( a and b )
endfunction

function Trig_RP_PDD_Actions takes nothing returns nothing
    local unit c = udg_PDD_source
    local real rh = 0.11 * GetUnitMaxLife(c)
    local real rc = 0.11 * GetUnitMaxLife(udg_PDD_target)
    local real rd = 0.11 * GetUnitState(c, UNIT_STATE_MAX_MANA)
    local location p = GetUnitLoc(udg_PDD_source)
    // rh is the heal amount
    local integer i = GetRandomInt(1,4)
    local group g = GetUnitsInRangeOfLocMatching(1100, p, Condition(function Trig_RP_PDD_Filter))
    local unit d
    local unit u
    if ( i == 1 ) then
        // draw trigger
        call SetUnitState(c, UNIT_STATE_MANA, GetUnitState(c, UNIT_STATE_MANA) + rd )
        call FadingText( "DRAW" , c, 17, 100.00, 60.00, 40.00, 0 )
    elseif ( i == 2 ) then
        // stand trigger
        set d = CreateUnitAtLoc( GetOwningPlayer(c), 'h00A',  p, bj_UNIT_FACING )
        call UnitApplyTimedLifeBJ( 23, 'BTLF', d )
        set d = CreateUnitAtLoc( GetOwningPlayer(c), 'h00A',  p, bj_UNIT_FACING )
        call UnitApplyTimedLifeBJ( 23, 'BTLF', d )
        call FadingText( "STAND" , c, 17, 20.00, 20.00, 100.00, 0 )
    elseif ( i == 3 ) then
        // crit trigger
        set udg_PDD_amount = udg_PDD_amount + rc
        call FadingText ( "CRIT" , c, 17, 80.00, 80.00, 20.00, 0 )
    elseif ( i == 4 ) then
        // heal trigger
        call SetUnitLife(c, (GetUnitLife(c)+rh))
        call FadingText( "HEAL" , c, 17, 20.00, 100.00, 20.00, 0 )
    endif
    loop 
        set u = FirstOfGroup (g)
        exitwhen u == null
        call IncUnitAbilityLevel(u, 'A06A')
        call GroupRemoveUnit(g,u)
    endloop
    set c = null
    set g = null
endfunction

function Trig_SR_PDD_Conditions takes nothing returns boolean
    if ( not ( IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source)) == true ) ) then
        return false
    endif
    if ( not ( udg_PDD_damageType == udg_PDD_PHYSICAL ) ) then
        return false
    endif
    if ( not ( GetUnitTypeId(udg_PDD_source) == 'N011' ) ) then
        return false
    endif
    return true
endfunction

function Trig_SR_PDD_Actions takes nothing returns nothing
    local location p = GetUnitLoc(udg_PDD_target)
    local location pc = GetUnitLoc(udg_PDD_source)
    local real x = GetUnitMissingPercentLife(udg_PDD_target) * 0.19
    local integer v = GetUnitAbilityLevel(udg_PDD_source, 'A05W')
    local real rv = 0.2 + 0.01 * GetHeroLevel(udg_PDD_source)
    local integer i = GetRandomInt(1,9)
    if v > i then
        //damage
        set x = 0.003 * (19 + i) * (19 + x) //(1.14 to 3.19)
        set udg_PDD_amount = udg_PDD_amount * x
        call FadingText(I2S(R2I(udg_PDD_amount)) + "!", udg_PDD_target, 9 + x, 90, 90, 90, 0 )
        call SetUnitLife(udg_PDD_source, GetUnitLife(udg_PDD_source) + x * rv * udg_PDD_amount)
        //create lifesteal fx
        call CreateUnitAtLoc( GetOwningPlayer(udg_PDD_source), 'h02N', pc, bj_UNIT_FACING )
        call CreateUnitAtLoc( GetOwningPlayer(udg_PDD_source), 'h002', p, bj_UNIT_FACING )
        set v = v - i
    else
        set v = v + 3
    endif
    call SetUnitAbilityLevel(udg_PDD_source, 'A05W', v )
    //call DisplayTextToForce( GetPlayersAll(), I2S(v) )
    call RemoveLocation(pc)
    call RemoveLocation(p)
endfunction

function Trig_SQA_PDD_Conditions takes nothing returns boolean
    local real r = 45 + 3 * GetHeroLevel(udg_PDD_source)
    local boolean a = udg_PDD_damageType == udg_PDD_SPELL
    local boolean b = udg_PDD_damageType == udg_PDD_PHYSICAL
    local boolean c = GetUnitAbilityLevel(udg_PDD_source, 'B03A') > 0 
    if ( not ( IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source)) == true ) ) then
        return false
    endif
    if ( not ( a or (b and c) ) ) then
        return false
    endif
    if ( not ( GetUnitTypeId(udg_PDD_source) == 'N00D' ) ) then
        return false
    endif
    if ( not ( GetRandomReal(0,400) <= r) ) then
        return false
    endif
    return true
endfunction

function Trig_SQA_PDD_Actions takes nothing returns nothing
    local unit d
    local real xe = 0.12 * GetUnitAbilityLevel(udg_PDD_source, 'A03R')
    local real int = GetHeroInt(udg_PDD_source, true)*0.004 + GetHeroBonusInt(udg_PDD_source)*0.009
    local real r = GetRandomReal(1.2,1.4) + int + xe
    local integer i = GetUnitAbilityLevel(udg_PDD_source,'A03R')
    local location p = GetUnitLoc(udg_PDD_source)
    if GetUnitAbilityLevel(udg_PDD_source, 'A03R') > 0 then
        set d = CreateUnitAtLoc( GetOwningPlayer(udg_PDD_source), 'h000',  p, 0.00 )
        call UnitAddAbility( d, 'A032')
        call SetUnitAbilityLevel( d, 'A032', i)
        call IssueTargetOrder( d, "innerfire", udg_PDD_source )
        set d = null
    endif
    set udg_PDD_amount = ( udg_PDD_amount * r )
    call FadingText( ( I2S(R2I(udg_PDD_amount)) + "!!" ), udg_PDD_target, 12.00, 100.00, 100, 30, 0 )
    call RemoveLocation(p)
endfunction

function Trig_TC_PDD_Conditions takes nothing returns boolean
    if ( not ( IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source)) == true ) ) then
        return false
    endif
    if ( not ( GetUnitTypeId(udg_PDD_source) == 'N00U' ) ) then
        return false
    endif
    if ( IsUnitType (udg_PDD_target,UNIT_TYPE_STRUCTURE) ) then
        return false
    endif
    return true
endfunction

function Trig_TC_PDD_Actions takes nothing returns nothing
    local unit d
    local location pu = GetUnitLoc(udg_PDD_target)
    local real r =  0.02 * GetHeroInt(udg_PDD_source, true) + 0.08 * GetHeroBonusInt(udg_PDD_source)
    local integer i = GetUnitAbilityLevel(udg_PDD_source, 'A02Y')
    if (i > 0) then
        set d = CreateUnitAtLoc(GetOwningPlayer(udg_PDD_source), 'h000', pu, bj_UNIT_FACING )
        call UnitAddAbility(d, 'A066')
        call SetUnitAbilityLevel( d, 'A066', R2I(r) + 3 + i*5)
        call IssueTargetOrder( d, "slow", udg_PDD_target )
    endif
    //call DisplayTextToForce( GetPlayersAll(), "slow level = " + R2S(R2I(r) + i*8) )
    if ( not ( IsUnitType(udg_PDD_target, UNIT_TYPE_HERO) ) ) then
        set r = r * 0.125
    endif
    if (udg_PDD_damageType == udg_PDD_SPELL) then
        set r = r*2.8
    endif
    set udg_PDD_amount = ( udg_PDD_amount + 5.6*r )
    call SetUnitPercentLife(udg_PDD_source, GetUnitPercentLife(udg_PDD_source) + 0.08*r)
    //call DisplayTextToForce( GetPlayersAll(), "damage inc = " + R2S(2.8*r) )
    //call DisplayTextToForce( GetPlayersAll(), "%hp heal = " + R2S(0.08*r) )
    set d = null
    call RemoveLocation (pu)
endfunction

function Trig_TI_PDD_Filter takes nothing returns boolean
    local boolean a = IsUnitEnemy(GetFilterUnit(), GetOwningPlayer(udg_PDD_target))
    return (a and IsTarget())
endfunction

function Trig_TI_PDD_Conditions takes nothing returns boolean
    local boolean a = GetUnitTypeId(udg_PDD_target) == 'N01F'
    local boolean b = udg_PDD_amount > 0
    return a and b
endfunction

function Trig_TI_PDD_Actions takes nothing returns nothing
    local unit u
    local location p = GetUnitLoc(udg_PDD_target)
    local group g = GetUnitsInRangeOfLocMatching( 900, p, function Trig_TI_PDD_Filter )
    local real rv = (8 + 0.4 * I2R(GetHeroLevel(udg_PDD_target)))
    local real rt = 4 * GetUnitAbilityLevel(udg_PDD_target, 'A09Z')
    local real r = 0.01 * (rv + rt) * udg_PDD_amount
    set udg_PDD_amount = udg_PDD_amount - r 
    loop
        set u = FirstOfGroup(g)
        exitwhen u == null
        call UnitDamageTargetPDD( udg_PDD_target, u, r, 0 )
        call GroupRemoveUnit(g, u)
    endloop
    set u = null
    //call DisplayTextToForce( GetPlayersAll(), R2S(r) )
    call RemoveLocation (p)
    call DestroyGroup (g)
endfunction

function Trig_UW_PDD_Conditions takes nothing returns boolean
    if ( not ( IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source)) == true ) ) then
        return false
    endif
    if ( not ( udg_PDD_damageType == udg_PDD_PHYSICAL ) ) then
        return false
    endif
    if ( not ( GetUnitTypeId(udg_PDD_source) == 'N016' ) ) then
        return false
    endif
    return true
endfunction

function Trig_UW_PDD_Actions takes nothing returns nothing
    local texttag t
    local real r 
    local integer level = 8 + GetUnitAbilityLevel(udg_PDD_source,'A051') * 4
    local boolean a = GetUnitAbilityLevel(udg_PDD_source,'A051') > 0
    local boolean b = GetRandomInt(0,100) < level
    local location p = GetUnitLoc(udg_PDD_source)
    local unit d
    if (IsUnitIllusion(udg_PDD_source)) then
        if ( GetRandomReal(0, 200.00) <= (31 + I2R(GetUnitLevel(udg_PDD_source))) ) then
            set r = ( GetUnitMaxLife(udg_PDD_target) * 0.08 )
            set udg_PDD_amount = r
            call FadingText( ( I2S(R2I(r)) + "!" ), udg_PDD_target, 10.50, 100.00, 0, 60, 0 )
        else
            set udg_PDD_amount = 0
        endif
    else
        if IsUnitType(udg_PDD_target, UNIT_TYPE_HERO) then
            set udg_PDD_amount =  0.8 * udg_PDD_amount
        endif
        if (a and b) then
            set d = CreateUnitAtLoc( GetOwningPlayer(udg_PDD_source), 'h000', p, bj_UNIT_FACING )
            call UnitAddAbility( d,'A04W' )
            call IssueTargetOrderById(d,852274,udg_PDD_source)
            set d = null
        endif
    endif 
    call RemoveLocation (p)
    set d = null
endfunction

function Trig_WA_PDD_Conditions takes nothing returns boolean
    if ( not ( IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source))) ) then
        return false
    endif
    if ( not ( udg_PDD_damageType == udg_PDD_PHYSICAL ) ) then
        return false
    endif
    if ( not ( GetUnitTypeId(udg_PDD_source) == 'N01B' ) ) then
        return false
    endif
    return true
endfunction

function Trig_WA_PDD_Actions takes nothing returns nothing
    local unit ug
    local location pc = GetUnitLoc(udg_PDD_source)
    local location pu = GetUnitLoc(udg_PDD_target)
    local location pw
    local real angle
    local location pr1
    local location pr2
    //local group gp = GetUnitsInRangeOfLocMatching(480, pu, Condition(function Trig_WA_PDD_Filter)) 
    //local group g = GetRandomSubGroup(3, gp)
    local boolean a = udg_Moon_target == udg_PDD_target
    local boolean b = GetUnitAbilityLevel(udg_Moon_target,'B05D') > 0
    local real base = 0.3 + 0.012 * GetHeroLevel(udg_PDD_source)
    if a and b then
        set base = base * 1.2
    endif
    call Moonbeam(udg_PDD_source, pu, base)
    //call DisplayTextToForce( GetPlayersAll(), R2S(base) )
    if (GetUnitAbilityLevel(udg_PDD_source, 'B01S') == 1) then
        set angle = AngleBetweenPoints(pc, pu)
        set pr1 = PolarProjectionBJ(pc, 600, angle + 21)
        set pr2 = PolarProjectionBJ(pc, 600, angle - 21)
        call Moonbeam (udg_PDD_source, pr1, 0.5*base)
        call Moonbeam (udg_PDD_source, pr2, 0.5*base)
        call RemoveLocation (pr1)
        call RemoveLocation (pr2)
    endif
    set udg_PDD_amount = 0
    call RemoveLocation (pc)
    call RemoveLocation (pu)
    //call DestroyGroup (gp)
    //call DestroyGroup (g)
endfunction

function Trig_WW_PDD_Conditions takes nothing returns boolean
    if ( not ( IsUnitEnemy(udg_PDD_target, GetOwningPlayer(udg_PDD_source)) == true ) ) then
        return false
    endif
    if ( not ( IsUnitType(udg_PDD_target, UNIT_TYPE_HERO) == true ) ) then
        return false
    endif
    if ( not ( udg_PDD_damageType == udg_PDD_PHYSICAL ) ) then
        return false
    endif
    if ( not ( GetUnitTypeId(udg_PDD_source) == 'E002' ) ) then
        return false
    endif
    return true
endfunction

function Trig_WW_PDD_Actions takes nothing returns nothing
    local unit u = udg_PDD_target
    local unit c = udg_PDD_source
    local real r = (GetUnitManaPercent(udg_PDD_source) * 0.9 + 90)/100
    set udg_PDD_amount = udg_PDD_amount * r
    call SetUnitManaBJ( c, ( GetUnitState(c, UNIT_STATE_MANA) * 0.82 ) )
    call FadingText( ( I2S(R2I(udg_PDD_amount)) + "!" ), u, 14.00, 80.00, 80.00, 100, 0 )
    set c = null
    set u = null
endfunction



function Trig_Global_PDD_Actions takes nothing returns nothing
    //spell dummy
    if Trig_SpellDummy_PDD_Conditions() then
        call Trig_SpellDummy_PDD_Actions()
    elseif Trig_SpellAmp_PDD_Conditions() then
        call Trig_SpellAmp_PDD_Actions()
    elseif Trig_SpellComp_PDD_Conditions() then
        call Trig_SpellComp_PDD_Actions()
    //hero modified attacks/special dummy mod attack
    elseif Trig_AA_PDD_Conditions() then
        call Trig_AA_PDD_Actions()
    elseif Trig_AR_PDD_Conditions() then
        call Trig_AR_PDD_Actions()
    elseif Trig_BM_PDD_Conditions() then
        call Trig_BM_PDD_Actions()
    elseif Trig_BO_PDD_Conditions() then
        call Trig_BO_PDD_Actions()
    elseif Trig_BT_PDD_Conditions() then
        call Trig_BT_PDD_Actions()
    elseif Trig_CS_PDD_Conditions() then
        call Trig_CS_PDD_Actions()
    elseif Trig_DN_PDD_Conditions() then
        call Trig_DN_PDD_Actions()
    elseif Trig_DC_PDD_Conditions() then
        call Trig_DC_PDD_Actions()
    elseif Trig_EM_PDD_Conditions() then
        call Trig_EM_PDD_Actions()
    elseif Trig_FS_PDD_Conditions() then
        call Trig_FS_PDD_Actions()
    elseif Trig_FMD_PDD_Conditions() then
        call Trig_FMD_PDD_Actions()
    elseif Trig_FMD_PDD_2_Conditions() then
        call Trig_FMD_PDD_2_Actions()
    elseif Trig_GS_PDD_Conditions() then
        call Trig_GS_PDD_Actions()
    elseif Trig_HO_PDD_Conditions() then
        call Trig_HO_PDD_Actions()
    elseif Trig_HQ_PDD_Conditions() then
        call Trig_HQ_PDD_Actions()
    elseif Trig_IN_PDD_Conditions() then
        call Trig_IN_PDD_Actions()
    elseif Trig_MA_PDD_Conditions() then
        call Trig_MA_PDD_Actions()
    elseif Trig_NP_PDD_Conditions() then
        call Trig_NP_PDD_Actions()
    elseif Trig_PS_PDD_Conditions() then
        call Trig_PS_PDD_Actions()
    elseif Trig_PT_PDD_Conditions() then
        call Trig_PT_PDD_Actions()
    elseif Trig_RB_PDD_Conditions() then
        call Trig_RB_PDD_Actions()
    elseif Trig_RH_PDD_Conditions() then
        call Trig_RH_PDD_Actions()
    elseif Trig_RP_PDD_Conditions() then
        call Trig_RP_PDD_Actions()
    elseif Trig_SR_PDD_Conditions() then
        call Trig_SR_PDD_Actions()
    elseif Trig_SQA_PDD_Conditions() then
        call Trig_SQA_PDD_Actions()
    elseif Trig_TC_PDD_Conditions() then
        call Trig_TC_PDD_Actions()
    elseif Trig_UW_PDD_Conditions() then
        call Trig_UW_PDD_Actions()
    elseif Trig_WA_PDD_Conditions() then
        call Trig_WA_PDD_Actions()
    elseif Trig_WW_PDD_Conditions() then
        call Trig_WW_PDD_Actions()
    endif
    //defensive pdd
    if Trig_AD_PDD_Conditions() then
        call Trig_AD_PDD_Actions()
    elseif Trig_BO_PDD_2_Conditions() then
        call Trig_BO_PDD_2_Actions()
    elseif Trig_CS_PDD_2_Conditions() then
        call Trig_CS_PDD_2_Actions()
    elseif Trig_DC_PDD_2_Conditions() then
        call Trig_DC_PDD_2_Actions()
    elseif Trig_GW_PDD_Conditions() then
        call Trig_GW_PDD_Actions()
    elseif Trig_HV_PDD_Conditions() then
        call Trig_HV_PDD_Actions()
    elseif Trig_LM_PDD_Conditions() then
        call Trig_LM_PDD_Actions()
    elseif Trig_RB_PDD_2_Conditions() then
        call Trig_RB_PDD_2_Actions()
    elseif Trig_TI_PDD_Conditions() then
        call Trig_TI_PDD_Actions()
    endif
    //damage modifiers
    //if Trig_DamageMod_PDD_Conditions() then
    //   call Trig_DamageMod_PDD_Actions()
    //endif
    
endfunction

//===========================================================================
function InitTrig_Global_PDD takes nothing returns nothing
    set gg_trg_Global_PDD = CreateTrigger(  )
    call TriggerRegisterVariableEvent( gg_trg_Global_PDD, "udg_PDD_damageEventTrigger", EQUAL, 1.00 )
    call TriggerAddAction( gg_trg_Global_PDD, function Trig_Global_PDD_Actions )
endfunction