include "TriggerLibs/NativeLib"

include "TriggerLibs/HeroesLib"



include "LibHWHI_h"



//--------------------------------------------------------------------------------------------------

// Library: Whitemane

//--------------------------------------------------------------------------------------------------

// External Library Initialization

void libHWHI_InitLibraries () {

    libNtve_InitVariables();

    libCore_InitVariables();

}



// Variable Initialization

bool libHWHI_InitVariables_completed = false;



void libHWHI_InitVariables () {

    if (libHWHI_InitVariables_completed) {

        return;

    }



    libHWHI_InitVariables_completed = true;



}



// Functions

void libHWHI_gf_HeroWhitemaneIncrementHeroCountFunction () {

    // Automatic Variable Declarations

    // Implementation

    libHWHI_gv_heroWhitemaneTriggerRegistrationVariable += 1;

    if ((libHWHI_gv_heroWhitemaneTriggerRegistrationVariable == 1)) {

        TriggerEnable(libHWHI_gt_HeroWhitemaneZealAbilityDamageTracker, true);

        TriggerEnable(libHWHI_gt_HeroWhitemaneZealBasicDamageTracker, true);

        TriggerEnable(libHWHI_gt_HeroWhitemaneZealCombinedHeal, true);

        TriggerEnable(libHWHI_gt_HeroWhitemaneDivineReckoningAddLeech, true);

        TriggerEnable(libHWHI_gt_HeroWhitemaneDivineReckoningLeechProc, true);

    }



}



void libHWHI_gf_HeroWhitemaneDecrementHeroCountFunction () {

    // Automatic Variable Declarations

    // Implementation

    libHWHI_gv_heroWhitemaneTriggerRegistrationVariable -= 1;

    if ((libHWHI_gv_heroWhitemaneTriggerRegistrationVariable < 0)) {

        libHWHI_gv_heroWhitemaneTriggerRegistrationVariable = 0;

    }



    if ((libHWHI_gv_heroWhitemaneTriggerRegistrationVariable == 0)) {

        TriggerEnable(libHWHI_gt_HeroWhitemaneZealAbilityDamageTracker, false);

        TriggerEnable(libHWHI_gt_HeroWhitemaneZealBasicDamageTracker, false);

        TriggerEnable(libHWHI_gt_HeroWhitemaneZealCombinedHeal, false);

        TriggerEnable(libHWHI_gt_HeroWhitemaneDivineReckoningAddLeech, false);

        TriggerEnable(libHWHI_gt_HeroWhitemaneDivineReckoningLeechProc, false);

    }



}



// Triggers

//--------------------------------------------------------------------------------------------------

// Trigger: Hero - Whitemane - Zeal - Ability Damage Tracker

//--------------------------------------------------------------------------------------------------

bool libHWHI_gt_HeroWhitemaneZealAbilityDamageTracker_Func (bool testConds, bool runActions) {

    // Variable Declarations

    fixed lv_damageAmount;

    unit lv_itUnit;

    int lv_itPlayer;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_itUnit = EventUnitDamageSourceUnit();

    lv_itPlayer = UnitGetOwner(EventUnitDamageSourceUnit());



    // Conditions

    if (testConds) {

        if (!((UnitTypeTestAttribute(UnitGetType(EventUnit()), c_unitAttributeHeroic) == true))) {

            return false;

        }



        if (!((UnitBehaviorCount(lv_itUnit, "WhitemaneZealCasterBehavior") > 0))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if (((lv_itPlayer > libCore_gv_bALMaxPlayers) || (lv_itPlayer <= 0))) {

        return true;

    }



    lv_damageAmount = EventUnitDamageAbsorbed();

    libHWHI_gv_heroWhitemaneZealCombinedHeal[lv_itPlayer] += lv_damageAmount;

    return true;

}



//--------------------------------------------------------------------------------------------------

void libHWHI_gt_HeroWhitemaneZealAbilityDamageTracker_Init () {

    libHWHI_gt_HeroWhitemaneZealAbilityDamageTracker = TriggerCreate("libHWHI_gt_HeroWhitemaneZealAbilityDamageTracker_Func");

    TriggerEnable(libHWHI_gt_HeroWhitemaneZealAbilityDamageTracker, false);

    TriggerAddDamageEvent(libHWHI_gt_HeroWhitemaneZealAbilityDamageTracker, "HeroWhitemane", null, c_unitDamageTypeAbility, c_unitDamageEither, null);

}



//--------------------------------------------------------------------------------------------------

// Trigger: Hero - Whitemane - Zeal - Basic Damage Tracker

//--------------------------------------------------------------------------------------------------

bool libHWHI_gt_HeroWhitemaneZealBasicDamageTracker_Func (bool testConds, bool runActions) {

    // Variable Declarations

    fixed lv_damageAmount;

    unit lv_itUnit;

    int lv_itPlayer;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_itUnit = EventUnitDamageSourceUnit();

    lv_itPlayer = UnitGetOwner(EventUnitDamageSourceUnit());



    // Conditions

    if (testConds) {

        if (!((UnitTypeTestAttribute(UnitGetType(EventUnit()), c_unitAttributeHeroic) == true))) {

            return false;

        }



        if (!((UnitBehaviorCount(lv_itUnit, "WhitemaneZealCasterBehavior") > 0))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if (((lv_itPlayer > libCore_gv_bALMaxPlayers) || (lv_itPlayer <= 0))) {

        return true;

    }



    lv_damageAmount = EventUnitDamageAbsorbed();

    libHWHI_gv_heroWhitemaneZealCombinedHeal[lv_itPlayer] += lv_damageAmount;

    return true;

}



//--------------------------------------------------------------------------------------------------

void libHWHI_gt_HeroWhitemaneZealBasicDamageTracker_Init () {

    libHWHI_gt_HeroWhitemaneZealBasicDamageTracker = TriggerCreate("libHWHI_gt_HeroWhitemaneZealBasicDamageTracker_Func");

    TriggerEnable(libHWHI_gt_HeroWhitemaneZealBasicDamageTracker, false);

    TriggerAddDamageEvent(libHWHI_gt_HeroWhitemaneZealBasicDamageTracker, "HeroWhitemane", null, c_unitDamageTypeBasic, c_unitDamageEither, null);

}



//--------------------------------------------------------------------------------------------------

// Trigger: Hero - Whitemane - Zeal - Combined Heal

//--------------------------------------------------------------------------------------------------

bool libHWHI_gt_HeroWhitemaneZealCombinedHeal_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_itUnit;

    int lv_itPlayer;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_itUnit = EventPlayerEffectUsedUnit(c_effectUnitCaster);

    lv_itPlayer = UnitGetOwner(lv_itUnit);



    // Conditions

    if (testConds) {

        if (!((UnitGetType(lv_itUnit) == "HeroWhitemane"))) {

            return false;

        }



        if (!((libHWHI_gv_heroWhitemaneZealCombinedHeal[lv_itPlayer] > 0.0))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    CatalogFieldValueSetFixed(c_gameCatalogEffect, "WhitemaneZealCreateHealer", "RechargeVitalRate", lv_itPlayer, libHWHI_gv_heroWhitemaneZealCombinedHeal[lv_itPlayer]);

    UnitCreateEffectUnit(lv_itUnit, "WhitemaneZealEnumTrackedUnits", lv_itUnit);

    libHWHI_gv_heroWhitemaneZealCombinedHeal[lv_itPlayer] = 0.0;

    return true;

}



//--------------------------------------------------------------------------------------------------

void libHWHI_gt_HeroWhitemaneZealCombinedHeal_Init () {

    libHWHI_gt_HeroWhitemaneZealCombinedHeal = TriggerCreate("libHWHI_gt_HeroWhitemaneZealCombinedHeal_Func");

    TriggerEnable(libHWHI_gt_HeroWhitemaneZealCombinedHeal, false);

    TriggerAddEventPlayerEffectUsed(libHWHI_gt_HeroWhitemaneZealCombinedHeal, c_playerAny, "WhitemaneZealCombinedHealDummy");

}



//--------------------------------------------------------------------------------------------------

// Trigger: Hero - Whitemane - Divine Reckoning - Add Leech

//--------------------------------------------------------------------------------------------------

bool libHWHI_gt_HeroWhitemaneDivineReckoningAddLeech_Func (bool testConds, bool runActions) {

    // Variable Declarations

    fixed lv_damageAmount;

    int lv_whitemanePlayer;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_whitemanePlayer = EventUnitDamageSourcePlayer();



    // Conditions

    if (testConds) {

        if (!((UnitTypeTestAttribute(UnitGetType(EventUnit()), c_unitAttributeHeroic) == true))) {

            return false;

        }



        if (!((lv_whitemanePlayer > 0))) {

            return false;

        }



        if (!((lv_whitemanePlayer <= libCore_gv_bALMaxPlayers))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    lv_damageAmount = (EventUnitDamageAbsorbed() * CatalogFieldValueGetAsFixed(c_gameCatalogEffect, EventUnitDamageEffect(), "LeechFraction[" + IntToString(c_unitVitalEnergy) + "]", lv_whitemanePlayer));

    libHWHI_gv_heroWhitemaneDivineReckoningCombinedLeech[lv_whitemanePlayer] += lv_damageAmount;

    return true;

}



//--------------------------------------------------------------------------------------------------

void libHWHI_gt_HeroWhitemaneDivineReckoningAddLeech_Init () {

    libHWHI_gt_HeroWhitemaneDivineReckoningAddLeech = TriggerCreate("libHWHI_gt_HeroWhitemaneDivineReckoningAddLeech_Func");

    TriggerEnable(libHWHI_gt_HeroWhitemaneDivineReckoningAddLeech, false);

    TriggerAddDamageEvent(libHWHI_gt_HeroWhitemaneDivineReckoningAddLeech, "HeroWhitemane", null, c_unitDamageTypeAbility, c_unitDamageEither, "WhitemaneDivineReckoningDamage");

}



//--------------------------------------------------------------------------------------------------

// Trigger: Hero - Whitemane - Divine Reckoning - Leech Proc

//--------------------------------------------------------------------------------------------------

bool libHWHI_gt_HeroWhitemaneDivineReckoningLeechProc_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_whitemaneUnit;

    int lv_whitemanePlayer;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_whitemaneUnit = EventPlayerEffectUsedUnit(c_effectUnitCaster);

    lv_whitemanePlayer = EventPlayerEffectUsedUnitOwner(c_effectPlayerCaster);



    // Conditions

    if (testConds) {

        if (!((UnitGetType(lv_whitemaneUnit) == "HeroWhitemane"))) {

            return false;

        }



        if (!((libHWHI_gv_heroWhitemaneDivineReckoningCombinedLeech[lv_whitemanePlayer] > 0.0))) {

            return false;

        }



        if (!((lv_whitemanePlayer > 0))) {

            return false;

        }



        if (!((lv_whitemanePlayer <= libCore_gv_bALMaxPlayers))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    CatalogFieldValueSetFixed(c_gameCatalogEffect, "WhitemaneDivineReckoningRestoreMana", "RechargeVitalRate", lv_whitemanePlayer, libHWHI_gv_heroWhitemaneDivineReckoningCombinedLeech[lv_whitemanePlayer]);

    UnitCreateEffectUnit(lv_whitemaneUnit, "WhitemaneDivineReckoningRestoreManaSet", lv_whitemaneUnit);

    libHWHI_gv_heroWhitemaneDivineReckoningCombinedLeech[lv_whitemanePlayer] = 0.0;

    return true;

}



//--------------------------------------------------------------------------------------------------

void libHWHI_gt_HeroWhitemaneDivineReckoningLeechProc_Init () {

    libHWHI_gt_HeroWhitemaneDivineReckoningLeechProc = TriggerCreate("libHWHI_gt_HeroWhitemaneDivineReckoningLeechProc_Func");

    TriggerEnable(libHWHI_gt_HeroWhitemaneDivineReckoningLeechProc, false);

    TriggerAddEventPlayerEffectUsed(libHWHI_gt_HeroWhitemaneDivineReckoningLeechProc, c_playerAny, "WhitemaneDivineReckoningLeechProcDummy");

}



void libHWHI_InitTriggers () {

    libHWHI_gt_HeroWhitemaneZealAbilityDamageTracker_Init();

    libHWHI_gt_HeroWhitemaneZealBasicDamageTracker_Init();

    libHWHI_gt_HeroWhitemaneZealCombinedHeal_Init();

    libHWHI_gt_HeroWhitemaneDivineReckoningAddLeech_Init();

    libHWHI_gt_HeroWhitemaneDivineReckoningLeechProc_Init();

}



//--------------------------------------------------------------------------------------------------

// Library Initialization

//--------------------------------------------------------------------------------------------------

bool libHWHI_InitLib_completed = false;



void libHWHI_InitLib () {

    if (libHWHI_InitLib_completed) {

        return;

    }



    libHWHI_InitLib_completed = true;



    libHWHI_InitLibraries();

    libHWHI_InitVariables();

    libHWHI_InitTriggers();

}