include "TriggerLibs/NativeLib"

include "TriggerLibs/HeroesLib"

include "TriggerLibs/GameLib"

include "TriggerLibs/UILib"



include "LibHALE_h"



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

// Library: Alexstrasza

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

// External Library Initialization

void libHALE_InitLibraries () {

    libNtve_InitVariables();

    libCore_InitVariables();

    libGame_InitVariables();

    libUIUI_InitVariables();

}



// Variable Initialization

bool libHALE_InitVariables_completed = false;



void libHALE_InitVariables () {

    if (libHALE_InitVariables_completed) {

        return;

    }



    libHALE_InitVariables_completed = true;



}



// Functions

void libHALE_gf_HeroAlexstraszaIncrementHeroCountFunction () {

    // Automatic Variable Declarations

    // Implementation

    libHALE_gv_heroAlexstraszaTriggerRegistrationVariable += 1;

    if ((libHALE_gv_heroAlexstraszaTriggerRegistrationVariable == 1)) {

        TriggerEnable(libHALE_gt_HeroAlexstraszaLifebinder, true);

        TriggerEnable(libHALE_gt_HeroAlexstraszaCleansingFlameOverlayShow, true);

        TriggerEnable(libHALE_gt_HeroAlexstraszaCleansingFlameOverlayHide, true);

        TriggerEnable(libHALE_gt_HeroAlexstraszaCircleofLifeCreateRegenGlobe, true);

        TriggerEnable(libHALE_gt_HeroAlexstraszaOverprotective, true);

        TriggerEnable(libHALE_gt_HeroAlexstraszaBlessingoftheRedBehaviorUnitSwapped, true);

    }



}



void libHALE_gf_HeroAlexstraszaDecrementHeroCountFunction () {

    // Automatic Variable Declarations

    // Implementation

    libHALE_gv_heroAlexstraszaTriggerRegistrationVariable -= 1;

    if ((libHALE_gv_heroAlexstraszaTriggerRegistrationVariable < 0)) {

        libHALE_gv_heroAlexstraszaTriggerRegistrationVariable = 0;

    }



    if ((libHALE_gv_heroAlexstraszaTriggerRegistrationVariable == 0)) {

        TriggerEnable(libHALE_gt_HeroAlexstraszaLifebinder, false);

        TriggerEnable(libHALE_gt_HeroAlexstraszaCleansingFlameOverlayShow, false);

        TriggerEnable(libHALE_gt_HeroAlexstraszaCleansingFlameOverlayHide, false);

        TriggerEnable(libHALE_gt_HeroAlexstraszaCircleofLifeCreateRegenGlobe, false);

        TriggerEnable(libHALE_gt_HeroAlexstraszaOverprotective, false);

        TriggerEnable(libHALE_gt_HeroAlexstraszaBlessingoftheRedBehaviorUnitSwapped, false);

    }



}



// Triggers

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

// Trigger: Hero - Alexstrasza - Lifebinder

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

bool libHALE_gt_HeroAlexstraszaLifebinder_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_alexstrasza;

    unit lv_targetUnit;

    int lv_castingPlayer;

    fixed lv_alexstraszaHealthPercent;

    fixed lv_targetHealthPercent;

    fixed lv_healthModifyFraction;

    unit lv_setHealthTarget;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_alexstrasza = EventPlayerEffectUsedUnitImpact();

    lv_targetUnit = EventPlayerEffectUsedUnitLaunch();

    lv_castingPlayer = EventPlayer();

    lv_alexstraszaHealthPercent = UnitGetPropertyFixed(lv_alexstrasza, c_unitPropLifePercent, c_unitPropCurrent);

    lv_targetHealthPercent = UnitGetPropertyFixed(lv_targetUnit, c_unitPropLifePercent, c_unitPropCurrent);



    // Conditions

    if (testConds) {

        if (!((UnitIsAlive(lv_alexstrasza) == true))) {

            return false;

        }



        if (!((UnitIsAlive(lv_targetUnit) == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((lv_alexstraszaHealthPercent > lv_targetHealthPercent)) {

        lv_setHealthTarget = lv_targetUnit;

    }

    else {

        lv_setHealthTarget = lv_alexstrasza;

    }

    lv_healthModifyFraction = (AbsF((lv_targetHealthPercent - lv_alexstraszaHealthPercent)) / 100.0);

    CatalogFieldValueSetFixed(c_gameCatalogEffect, "AlexstraszaLifebinderCreateHealer", "RechargeVitalFraction", lv_castingPlayer, lv_healthModifyFraction);

    UnitCreateEffectUnit(lv_alexstrasza, "AlexstraszaLifebinderCreateHealer", lv_setHealthTarget);

    if ((lv_healthModifyFraction > 0.0)) {

        UnitCreateEffectUnit(lv_alexstrasza, "AlexstraszaPacifyLifeUnboundModifyCooldownHealSet", lv_setHealthTarget);

    }



    return true;

}



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

void libHALE_gt_HeroAlexstraszaLifebinder_Init () {

    libHALE_gt_HeroAlexstraszaLifebinder = TriggerCreate("libHALE_gt_HeroAlexstraszaLifebinder_Func");

    TriggerEnable(libHALE_gt_HeroAlexstraszaLifebinder, false);

    TriggerAddEventPlayerEffectUsed(libHALE_gt_HeroAlexstraszaLifebinder, c_playerAny, "AlexstraszaLifebinderActivationDummy");

}



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

// Trigger: Hero - Alexstrasza - Cleansing Flame Overlay Show

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

bool libHALE_gt_HeroAlexstraszaCleansingFlameOverlayShow_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_alexstrasza;

    int lv_player;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_alexstrasza = EventUnit();

    lv_player = UnitGetOwner(EventUnit());



    // Conditions

    if (testConds) {

        if (!((UnitHasBehavior2(lv_alexstrasza, "HeroGenericIgnoreFullscreenOverlay") == false))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((UnitHasBehavior2(lv_alexstrasza, "AlexstraszaDragonqueen") == true)) {

        Wait(0.3, c_timeGame);

        libUIUI_gf_FullscreenOverlayAddItemForPlayer(lv_player, libUIUI_ge_FullscreenOverlayPriorities_Stasis, "Cutscenes\\GameUI_AlexstraszaOverlay.StormCutscene", EventUnitBehavior());

    }

    else {

        libUIUI_gf_FullscreenOverlayAddItemForPlayer(lv_player, libUIUI_ge_FullscreenOverlayPriorities_Stasis, "Cutscenes\\GameUI_AlexstraszaOverlay.StormCutscene", EventUnitBehavior());

    }

    return true;

}



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

void libHALE_gt_HeroAlexstraszaCleansingFlameOverlayShow_Init () {

    libHALE_gt_HeroAlexstraszaCleansingFlameOverlayShow = TriggerCreate("libHALE_gt_HeroAlexstraszaCleansingFlameOverlayShow_Func");

    TriggerEnable(libHALE_gt_HeroAlexstraszaCleansingFlameOverlayShow, false);

    TriggerAddEventUnitBehaviorChange(libHALE_gt_HeroAlexstraszaCleansingFlameOverlayShow, null, "AlexstraszaCleansingFlameOverlayDummy", c_unitBehaviorChangeActivate);

}



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

// Trigger: Hero - Alexstrasza - Cleansing Flame Overlay Hide

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

bool libHALE_gt_HeroAlexstraszaCleansingFlameOverlayHide_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_alexstrasza;

    int lv_player;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_alexstrasza = EventUnit();

    lv_player = UnitGetOwner(lv_alexstrasza);



    // Actions

    if (!runActions) {

        return true;

    }



    Wait(2.0, c_timeGame);

    libUIUI_gf_FullscreenOverlayRemoveItemFromQueueForPlayer(lv_player, "Cutscenes\\GameUI_AlexstraszaOverlay.StormCutscene", EventUnitBehavior());

    return true;

}



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

void libHALE_gt_HeroAlexstraszaCleansingFlameOverlayHide_Init () {

    libHALE_gt_HeroAlexstraszaCleansingFlameOverlayHide = TriggerCreate("libHALE_gt_HeroAlexstraszaCleansingFlameOverlayHide_Func");

    TriggerEnable(libHALE_gt_HeroAlexstraszaCleansingFlameOverlayHide, false);

    TriggerAddEventUnitBehaviorChange(libHALE_gt_HeroAlexstraszaCleansingFlameOverlayHide, null, "AlexstraszaCleansingFlameOverlayDummy", c_unitBehaviorChangeDeactivate);

}



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

// Trigger: Hero - Alexstrasza - Blessing of the Red - Behavior Unit Swapped

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

bool libHALE_gt_HeroAlexstraszaBlessingoftheRedBehaviorUnitSwapped_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_oldUnit;

    unit lv_newUnit;

    unit lv_alexstraszaUnit;

    bool lv_preserveOnOld;



    // Automatic Variable Declarations

    const int auto3C680C14_ae = libCore_gv_bALMaxPlayers;

    int auto3C680C14_var;



    // Variable Initialization

    lv_oldUnit = libGame_gf_HeroUnitSwappedForPlayerOldUnit();

    lv_newUnit = libGame_gf_HeroUnitSwappedForPlayerNewUnit();

    lv_preserveOnOld = libGame_gf_HeroUnitSwappedForPlayerPreserveOnOld();



    // Actions

    if (!runActions) {

        return true;

    }



    auto3C680C14_var = 1;

    for ( ; auto3C680C14_var <= auto3C680C14_ae; auto3C680C14_var += 1 ) {

        if ((UnitBehaviorEnabled(lv_oldUnit, "AlexstraszaBlessingOfTheRed") == true) && (UnitBehaviorEffectPlayer(lv_oldUnit, "AlexstraszaBlessingOfTheRed", c_effectPlayerCaster, 0) == auto3C680C14_var) && (UnitFilterMatch(lv_newUnit, UnitGetOwner(lv_oldUnit), UnitFilter(0, 0, 0, (1 << (c_targetFilterAITargetableStructure - 32)))) == true)) {

            lv_alexstraszaUnit = libGame_gv_players[auto3C680C14_var].lv_heroUnit;

            if ((lv_preserveOnOld == false)) {

                UnitCreateEffectUnit(lv_alexstraszaUnit, "AlexstraszaBlessingOfTheRedRemoveBehavior", lv_oldUnit);

            }



            UnitCreateEffectUnit(lv_alexstraszaUnit, "AlexstraszaBlessingOfTheRedApplyBehavior", lv_newUnit);

        }



    }

    return true;

}



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

void libHALE_gt_HeroAlexstraszaBlessingoftheRedBehaviorUnitSwapped_Init () {

    libHALE_gt_HeroAlexstraszaBlessingoftheRedBehaviorUnitSwapped = TriggerCreate("libHALE_gt_HeroAlexstraszaBlessingoftheRedBehaviorUnitSwapped_Func");

    TriggerEnable(libHALE_gt_HeroAlexstraszaBlessingoftheRedBehaviorUnitSwapped, false);

    libGame_gf_HeroUnitSwappedForPlayer(libHALE_gt_HeroAlexstraszaBlessingoftheRedBehaviorUnitSwapped);

}



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

// Trigger: Hero - Alexstrasza - Circle of Life (Create Regen Globe)

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

bool libHALE_gt_HeroAlexstraszaCircleofLifeCreateRegenGlobe_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_castingPlayer;

    point lv_targetPoint;

    int lv_globeOwner;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_castingPlayer = EventPlayer();

    lv_targetPoint = EventPlayerEffectUsedPoint(c_effectLocationTargetPoint);



    // Actions

    if (!runActions) {

        return true;

    }



    if ((libGame_gf_TeamNumberOfPlayer(lv_castingPlayer) == libGame_gv_teamOrderIndex_C)) {

        lv_globeOwner = libCore_gv_cOMPUTER_TeamOrder;

    }

    else {

        lv_globeOwner = libCore_gv_cOMPUTER_TeamChaos;

    }

    libNtve_gf_CreateUnitsWithDefaultFacing(1, "RegenGlobe", c_unitCreateIgnorePlacement, lv_globeOwner, lv_targetPoint, EventPlayerEffectUsedUnit(c_effectUnitCaster));

    return true;

}



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

void libHALE_gt_HeroAlexstraszaCircleofLifeCreateRegenGlobe_Init () {

    libHALE_gt_HeroAlexstraszaCircleofLifeCreateRegenGlobe = TriggerCreate("libHALE_gt_HeroAlexstraszaCircleofLifeCreateRegenGlobe_Func");

    TriggerEnable(libHALE_gt_HeroAlexstraszaCircleofLifeCreateRegenGlobe, false);

    TriggerAddEventPlayerEffectUsed(libHALE_gt_HeroAlexstraszaCircleofLifeCreateRegenGlobe, c_playerAny, "AlexstraszaCircleOfLifeAbundanceCreateRegenGlobeDummy");

}



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

// Trigger: Hero - Alexstrasza - Overprotective

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

bool libHALE_gt_HeroAlexstraszaOverprotective_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_alexstrasza;

    int lv_healingPlayer;

    unit lv_targetUnit;

    fixed lv_healAmount;

    fixed lv_shieldAmountFactor;

    fixed lv_shieldAmount;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_alexstrasza = EventUnitHealLaunchUnit();

    lv_healingPlayer = EventUnitHealLaunchPlayer();

    lv_targetUnit = EventUnit();

    lv_healAmount = EventUnitHealAmount();

    lv_shieldAmountFactor = CatalogFieldValueGetAsFixed(c_gameCatalogEffect, "AlexstraszaOverprotectiveAbundanceShieldFractionScaleDummy", "VitalArray[" + IntToString(1) + "].ChangeFraction", lv_healingPlayer);

    lv_shieldAmount = (lv_healAmount * lv_shieldAmountFactor);



    // Conditions

    if (testConds) {

        if (!((PlayerHasTalent(EventUnitHealLaunchPlayer(), "AlexstraszaOverprotectiveAbundance") == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((lv_shieldAmount > 0.0)) {

        CatalogFieldValueSetFixed(c_gameCatalogBehavior, "AlexstraszaOverprotectiveAbundance", "DamageResponse.ModifyLimit", lv_healingPlayer, lv_shieldAmount);

        UnitBehaviorAdd(lv_targetUnit, "AlexstraszaOverprotectiveAbundance", lv_alexstrasza, 1);

    }



    return true;

}



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

void libHALE_gt_HeroAlexstraszaOverprotective_Init () {

    libHALE_gt_HeroAlexstraszaOverprotective = TriggerCreate("libHALE_gt_HeroAlexstraszaOverprotective_Func");

    TriggerEnable(libHALE_gt_HeroAlexstraszaOverprotective, false);

    TriggerAddEventUnitHealed(libHALE_gt_HeroAlexstraszaOverprotective, null, c_unitVitalLife, "AlexstraszaAbundanceCreateHealer");

}



void libHALE_InitTriggers () {

    libHALE_gt_HeroAlexstraszaLifebinder_Init();

    libHALE_gt_HeroAlexstraszaCleansingFlameOverlayShow_Init();

    libHALE_gt_HeroAlexstraszaCleansingFlameOverlayHide_Init();

    libHALE_gt_HeroAlexstraszaBlessingoftheRedBehaviorUnitSwapped_Init();

    libHALE_gt_HeroAlexstraszaCircleofLifeCreateRegenGlobe_Init();

    libHALE_gt_HeroAlexstraszaOverprotective_Init();

}



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

// Library Initialization

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

bool libHALE_InitLib_completed = false;



void libHALE_InitLib () {

    if (libHALE_InitLib_completed) {

        return;

    }



    libHALE_InitLib_completed = true;



    libHALE_InitLibraries();

    libHALE_InitVariables();

    libHALE_InitTriggers();

}