PTR build 2.57.1.98674_ptr. Go to the live site.

mods/heromods/alexstrasza.stormmod/base.stormdata/libhale.galaxy

libhale.galaxy
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");
    TriggerAddEventUnitHealed(libHALE_gt_HeroAlexstraszaOverprotective, null, c_unitVitalLife, "AlexstraszaPreservationCreateHealer");
}

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();
}