mods/heromods/yrel.stormmod/base.stormdata/libhyrl.galaxy

libhyrl.galaxy
include "TriggerLibs/NativeLib"
include "TriggerLibs/HeroesLib"
include "TriggerLibs/GameLib"
include "TriggerLibs/UILib"
include "TriggerLibs/GameDataHelperLib"

include "LibHYRL_h"

//--------------------------------------------------------------------------------------------------
// Library: Yrel
//--------------------------------------------------------------------------------------------------
// External Library Initialization
void libHYRL_InitLibraries () {
    libNtve_InitVariables();
    libCore_InitVariables();
    libGame_InitVariables();
    libUIUI_InitVariables();
    libGDHL_InitVariables();
}

// Variable Initialization
bool libHYRL_InitVariables_completed = false;

void libHYRL_InitVariables () {
    if (libHYRL_InitVariables_completed) {
        return;
    }

    libHYRL_InitVariables_completed = true;

    libHYRL_gv_heroYrelArdentDefenderDamageConversionScale = CatalogFieldValueGetAsFixed(c_gameCatalogEffect, "YrelArdentDefenderDamageConversionScaleDummyModifyUnit", "XP", 0);
}

// Functions
void libHYRL_gf_HeroYrelIncrementHeroCountFunction () {
    // Automatic Variable Declarations
    // Implementation
    libHYRL_gv_heroYrelTriggerRegistrationVariable += 1;
    if ((libHYRL_gv_heroYrelTriggerRegistrationVariable == 1)) {
        TriggerEnable(libHYRL_gt_HeroYrelHeroSpawned, true);
        TriggerEnable(libHYRL_gt_HeroYrelAbathurUltimateEvolutionHeroCopied, true);
        TriggerEnable(libHYRL_gt_HeroYrelGameOverEvent, true);
        TriggerEnable(libHYRL_gt_HeroYrelVindicationOn, true);
        TriggerEnable(libHYRL_gt_HeroYrelVindicationOff, true);
        TriggerEnable(libHYRL_gt_HeroYrelRighteousHammerOn, true);
        TriggerEnable(libHYRL_gt_HeroYrelRighteousHammerOff, true);
        TriggerEnable(libHYRL_gt_HeroYrelAvengingWrathOn, true);
        TriggerEnable(libHYRL_gt_HeroYrelAvengingWrathOff, true);
        TriggerEnable(libHYRL_gt_HeroYrelArdentDefenderOn, true);
        TriggerEnable(libHYRL_gt_HeroYrelArdentDefenderOff, true);
        TriggerEnable(libHYRL_gt_HeroYrelBubbleHearthOverlayOn, true);
        TriggerEnable(libHYRL_gt_HeroYrelBubbleHearthOverlayOff, true);
        TriggerEnable(libHYRL_gt_HeroYrelBubbleHearthHearthstoneTalentDisableCheck, true);
    }

    TriggerExecute(libHYRL_gt_HeroYrelHeroSpawned, true, false);
}

void libHYRL_gf_HeroYrelDecrementHeroCountFunction () {
    // Automatic Variable Declarations
    // Implementation
    libHYRL_gv_heroYrelTriggerRegistrationVariable -= 1;
    if ((libHYRL_gv_heroYrelTriggerRegistrationVariable < 0)) {
        libHYRL_gv_heroYrelTriggerRegistrationVariable = 0;
    }

    if ((libHYRL_gv_heroYrelTriggerRegistrationVariable == 0)) {
        TriggerEnable(libHYRL_gt_HeroYrelHeroSpawned, false);
        TriggerEnable(libHYRL_gt_HeroYrelAbathurUltimateEvolutionHeroCopied, false);
        TriggerEnable(libHYRL_gt_HeroYrelGameOverEvent, false);
        libHYRL_gv_heroYrelVindicationPlayerCount = 0;
        TriggerEnable(libHYRL_gt_HeroYrelVindicationOn, false);
        TriggerEnable(libHYRL_gt_HeroYrelVindicationPlayerClicked, false);
        TriggerEnable(libHYRL_gt_HeroYrelVindicationOff, false);
        libHYRL_gv_heroYrelRighteousHammerPlayerCount = 0;
        TriggerEnable(libHYRL_gt_HeroYrelRighteousHammerOn, false);
        TriggerEnable(libHYRL_gt_HeroYrelRighteousHammerPlayerClicked, false);
        TriggerEnable(libHYRL_gt_HeroYrelRighteousHammerOff, false);
        libHYRL_gv_heroYrelAvengingWrathPlayerCount = 0;
        TriggerEnable(libHYRL_gt_HeroYrelAvengingWrathOn, false);
        TriggerEnable(libHYRL_gt_HeroYrelAvengingWrathPlayerClicked, false);
        TriggerEnable(libHYRL_gt_HeroYrelAvengingWrathOff, false);
        libHYRL_gv_heroYrelArdentDefenderPlayerCount = 0;
        TriggerEnable(libHYRL_gt_HeroYrelArdentDefenderOn, false);
        TriggerEnable(libHYRL_gt_HeroYrelArdentDefenderDamageTracker, false);
        TriggerEnable(libHYRL_gt_HeroYrelArdentDefenderOff, false);
        TriggerEnable(libHYRL_gt_HeroYrelBubbleHearthOverlayOn, false);
        TriggerEnable(libHYRL_gt_HeroYrelBubbleHearthOverlayOff, false);
        TriggerEnable(libHYRL_gt_HeroYrelBubbleHearthHearthstoneTalentDisableCheck, false);
    }

}

// Triggers
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Yrel - Hero Spawned
//--------------------------------------------------------------------------------------------------
bool libHYRL_gt_HeroYrelHeroSpawned_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_playerID;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_playerID = libGame_gf_HeroSpawnPlayer();

    // Conditions
    if (testConds) {
        if (!((UnitGetType(libGame_gv_players[lv_playerID].lv_heroUnit) == "HeroYrel"))) {
            return false;
        }
    }

    // Actions
    if (!runActions) {
        return true;
    }

    TriggerAddEventMouseClicked(libHYRL_gt_HeroYrelVindicationPlayerClicked, lv_playerID, c_mouseButtonLeft,true);
    TriggerAddEventMouseClicked(libHYRL_gt_HeroYrelRighteousHammerPlayerClicked, lv_playerID, c_mouseButtonLeft,true);
    TriggerAddEventMouseClicked(libHYRL_gt_HeroYrelAvengingWrathPlayerClicked, lv_playerID, c_mouseButtonLeft,true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHYRL_gt_HeroYrelHeroSpawned_Init () {
    libHYRL_gt_HeroYrelHeroSpawned = TriggerCreate("libHYRL_gt_HeroYrelHeroSpawned_Func");
    TriggerEnable(libHYRL_gt_HeroYrelHeroSpawned, false);
    libGame_gf_HeroSpawn(libHYRL_gt_HeroYrelHeroSpawned);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Yrel - Abathur Ultimate Evolution Hero Copied
//--------------------------------------------------------------------------------------------------
bool libHYRL_gt_HeroYrelAbathurUltimateEvolutionHeroCopied_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_playerID;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_playerID = libGDHL_gf_AbathurUltimateEvolutionHeroCopiedAbathurOwner();

    // Conditions
    if (testConds) {
        if (!((UnitGetType(libGame_gv_players[lv_playerID].lv_heroUnit) == "HeroAbathur"))) {
            return false;
        }
    }

    // Actions
    if (!runActions) {
        return true;
    }

    TriggerAddEventMouseClicked(libHYRL_gt_HeroYrelVindicationPlayerClicked, lv_playerID, c_mouseButtonLeft,true);
    TriggerAddEventMouseClicked(libHYRL_gt_HeroYrelRighteousHammerPlayerClicked, lv_playerID, c_mouseButtonLeft,true);
    TriggerAddEventMouseClicked(libHYRL_gt_HeroYrelAvengingWrathPlayerClicked, lv_playerID, c_mouseButtonLeft,true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHYRL_gt_HeroYrelAbathurUltimateEvolutionHeroCopied_Init () {
    libHYRL_gt_HeroYrelAbathurUltimateEvolutionHeroCopied = TriggerCreate("libHYRL_gt_HeroYrelAbathurUltimateEvolutionHeroCopied_Func");
    TriggerEnable(libHYRL_gt_HeroYrelAbathurUltimateEvolutionHeroCopied, false);
    libGDHL_gf_AbathurUltimateEvolutionHeroCopied(libHYRL_gt_HeroYrelAbathurUltimateEvolutionHeroCopied);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Yrel - Game Over Event
//--------------------------------------------------------------------------------------------------
bool libHYRL_gt_HeroYrelGameOverEvent_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_itPlayer;

    // Automatic Variable Declarations
    const int auto27FD1D5C_ae = libCore_gv_bALMaxPlayers;
    const int auto27FD1D5C_ai = 1;

    // Variable Initialization

    // Actions
    if (!runActions) {
        return true;
    }

    lv_itPlayer = 1;
    for ( ; ( (auto27FD1D5C_ai >= 0 && lv_itPlayer <= auto27FD1D5C_ae) || (auto27FD1D5C_ai < 0 && lv_itPlayer >= auto27FD1D5C_ae) ) ; lv_itPlayer += auto27FD1D5C_ai ) {
        if ((UnitGetType(libGame_gv_players[lv_itPlayer].lv_heroUnit) == "HeroYrel")) {
            UnitBehaviorRemove(libGame_gv_players[lv_itPlayer].lv_heroUnit, "YrelVindicationChannelBuff", c_unitBehaviorCountAll);
            UnitBehaviorRemove(libGame_gv_players[lv_itPlayer].lv_heroUnit, "YrelRighteousHammerChannelBuff", c_unitBehaviorCountAll);
            UnitBehaviorRemove(libGame_gv_players[lv_itPlayer].lv_heroUnit, "YrelAvengingWrathChannelBuff", c_unitBehaviorCountAll);
            UnitBehaviorRemove(libGame_gv_players[lv_itPlayer].lv_heroUnit, "YrelDivinePurposeBuff", c_unitBehaviorCountAll);
        }

        if ((UnitGetType(libGame_gv_players[lv_itPlayer].lv_activeVehicle) == "HeroYrel")) {
            UnitBehaviorRemove(libGame_gv_players[lv_itPlayer].lv_activeVehicle, "YrelVindicationChannelBuff", c_unitBehaviorCountAll);
            UnitBehaviorRemove(libGame_gv_players[lv_itPlayer].lv_activeVehicle, "YrelRighteousHammerChannelBuff", c_unitBehaviorCountAll);
            UnitBehaviorRemove(libGame_gv_players[lv_itPlayer].lv_activeVehicle, "YrelAvengingWrathChannelBuff", c_unitBehaviorCountAll);
            UnitBehaviorRemove(libGame_gv_players[lv_itPlayer].lv_activeVehicle, "YrelDivinePurposeBuff", c_unitBehaviorCountAll);
        }

    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHYRL_gt_HeroYrelGameOverEvent_Init () {
    libHYRL_gt_HeroYrelGameOverEvent = TriggerCreate("libHYRL_gt_HeroYrelGameOverEvent_Func");
    TriggerEnable(libHYRL_gt_HeroYrelGameOverEvent, false);
    TriggerAddEventUnitDied(libHYRL_gt_HeroYrelGameOverEvent, UnitRefFromVariable("libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_core"));
    TriggerAddEventUnitDied(libHYRL_gt_HeroYrelGameOverEvent, UnitRefFromVariable("libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_core"));
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Yrel - Vindication - On
//--------------------------------------------------------------------------------------------------
bool libHYRL_gt_HeroYrelVindicationOn_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libHYRL_gv_heroYrelVindicationPlayerCount += 1;
    TriggerEnable(libHYRL_gt_HeroYrelVindicationPlayerClicked, true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHYRL_gt_HeroYrelVindicationOn_Init () {
    libHYRL_gt_HeroYrelVindicationOn = TriggerCreate("libHYRL_gt_HeroYrelVindicationOn_Func");
    TriggerEnable(libHYRL_gt_HeroYrelVindicationOn, false);
    TriggerAddEventUnitBehaviorChange(libHYRL_gt_HeroYrelVindicationOn, null, "YrelVindicationChannelBuff", c_unitBehaviorChangeActivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Yrel - Vindication - Player Clicked
//--------------------------------------------------------------------------------------------------
bool libHYRL_gt_HeroYrelVindicationPlayerClicked_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_playerID;
    unit lv_heroUnit;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_playerID = EventPlayer();
    lv_heroUnit = libGame_gv_players[lv_playerID].lv_heroUnit;

    // Conditions
    if (testConds) {
        if (!((EventKeyAlt() == false))) {
            return false;
        }
    }

    // Actions
    if (!runActions) {
        return true;
    }

    if ((UnitHasBehavior2(lv_heroUnit, "YrelVindicationChannelBuff") == true)) {
        UnitIssueOrder(lv_heroUnit, Order(AbilityCommand("YrelVindicationCast", 0)), c_orderQueueReplace);
        return true;
    }

    if ((UnitGetType(libGame_gv_players[lv_playerID].lv_heroUnit) == "HeroAbathur") && (UnitHasBehavior2(libGame_gv_players[lv_playerID].lv_activeVehicle, "YrelVindicationChannelBuff") == true)) {
        UnitIssueOrder(libGame_gv_players[lv_playerID].lv_activeVehicle, Order(AbilityCommand("YrelVindicationCast", 0)), c_orderQueueReplace);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libHYRL_gt_HeroYrelVindicationPlayerClicked_Init () {
    libHYRL_gt_HeroYrelVindicationPlayerClicked = TriggerCreate("libHYRL_gt_HeroYrelVindicationPlayerClicked_Func");
    TriggerEnable(libHYRL_gt_HeroYrelVindicationPlayerClicked, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Yrel - Vindication - Off
//--------------------------------------------------------------------------------------------------
bool libHYRL_gt_HeroYrelVindicationOff_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libHYRL_gv_heroYrelVindicationPlayerCount -= 1;
    if ((libHYRL_gv_heroYrelVindicationPlayerCount < 0)) {
        libHYRL_gv_heroYrelVindicationPlayerCount = 0;
    }

    if ((libHYRL_gv_heroYrelVindicationPlayerCount == 0)) {
        TriggerEnable(libHYRL_gt_HeroYrelVindicationPlayerClicked, false);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libHYRL_gt_HeroYrelVindicationOff_Init () {
    libHYRL_gt_HeroYrelVindicationOff = TriggerCreate("libHYRL_gt_HeroYrelVindicationOff_Func");
    TriggerEnable(libHYRL_gt_HeroYrelVindicationOff, false);
    TriggerAddEventUnitBehaviorChange(libHYRL_gt_HeroYrelVindicationOff, null, "YrelVindicationChannelBuff", c_unitBehaviorChangeDeactivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Yrel - Righteous Hammer - On
//--------------------------------------------------------------------------------------------------
bool libHYRL_gt_HeroYrelRighteousHammerOn_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libHYRL_gv_heroYrelRighteousHammerPlayerCount += 1;
    TriggerEnable(libHYRL_gt_HeroYrelRighteousHammerPlayerClicked, true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHYRL_gt_HeroYrelRighteousHammerOn_Init () {
    libHYRL_gt_HeroYrelRighteousHammerOn = TriggerCreate("libHYRL_gt_HeroYrelRighteousHammerOn_Func");
    TriggerEnable(libHYRL_gt_HeroYrelRighteousHammerOn, false);
    TriggerAddEventUnitBehaviorChange(libHYRL_gt_HeroYrelRighteousHammerOn, null, "YrelRighteousHammerChannelBuff", c_unitBehaviorChangeActivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Yrel - Righteous Hammer - Player Clicked
//--------------------------------------------------------------------------------------------------
bool libHYRL_gt_HeroYrelRighteousHammerPlayerClicked_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_playerID;
    unit lv_heroUnit;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_playerID = EventPlayer();
    lv_heroUnit = libGame_gv_players[lv_playerID].lv_heroUnit;

    // Conditions
    if (testConds) {
        if (!((EventKeyAlt() == false))) {
            return false;
        }
    }

    // Actions
    if (!runActions) {
        return true;
    }

    if ((UnitHasBehavior2(lv_heroUnit, "YrelRighteousHammerChannelBuff") == true)) {
        UnitIssueOrder(lv_heroUnit, OrderTargetingPoint(AbilityCommand("YrelRighteousHammer", 0), Point(EventMouseClickedPosXWorld(), EventMouseClickedPosYWorld())), c_orderQueueReplace);
        return true;
    }

    if ((UnitGetType(libGame_gv_players[lv_playerID].lv_heroUnit) == "HeroAbathur") && (UnitHasBehavior2(libGame_gv_players[lv_playerID].lv_activeVehicle, "YrelRighteousHammerChannelBuff") == true)) {
        UnitIssueOrder(libGame_gv_players[lv_playerID].lv_activeVehicle, OrderTargetingPoint(AbilityCommand("YrelRighteousHammer", 0), Point(EventMouseClickedPosXWorld(), EventMouseClickedPosYWorld())), c_orderQueueReplace);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libHYRL_gt_HeroYrelRighteousHammerPlayerClicked_Init () {
    libHYRL_gt_HeroYrelRighteousHammerPlayerClicked = TriggerCreate("libHYRL_gt_HeroYrelRighteousHammerPlayerClicked_Func");
    TriggerEnable(libHYRL_gt_HeroYrelRighteousHammerPlayerClicked, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Yrel - Righteous Hammer - Off
//--------------------------------------------------------------------------------------------------
bool libHYRL_gt_HeroYrelRighteousHammerOff_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libHYRL_gv_heroYrelRighteousHammerPlayerCount -= 1;
    if ((libHYRL_gv_heroYrelRighteousHammerPlayerCount < 0)) {
        libHYRL_gv_heroYrelRighteousHammerPlayerCount = 0;
    }

    if ((libHYRL_gv_heroYrelRighteousHammerPlayerCount == 0)) {
        TriggerEnable(libHYRL_gt_HeroYrelRighteousHammerPlayerClicked, false);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libHYRL_gt_HeroYrelRighteousHammerOff_Init () {
    libHYRL_gt_HeroYrelRighteousHammerOff = TriggerCreate("libHYRL_gt_HeroYrelRighteousHammerOff_Func");
    TriggerEnable(libHYRL_gt_HeroYrelRighteousHammerOff, false);
    TriggerAddEventUnitBehaviorChange(libHYRL_gt_HeroYrelRighteousHammerOff, null, "YrelRighteousHammerChannelBuff", c_unitBehaviorChangeDeactivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Yrel - Avenging Wrath - On
//--------------------------------------------------------------------------------------------------
bool libHYRL_gt_HeroYrelAvengingWrathOn_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libHYRL_gv_heroYrelAvengingWrathPlayerCount += 1;
    TriggerEnable(libHYRL_gt_HeroYrelAvengingWrathPlayerClicked, true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHYRL_gt_HeroYrelAvengingWrathOn_Init () {
    libHYRL_gt_HeroYrelAvengingWrathOn = TriggerCreate("libHYRL_gt_HeroYrelAvengingWrathOn_Func");
    TriggerEnable(libHYRL_gt_HeroYrelAvengingWrathOn, false);
    TriggerAddEventUnitBehaviorChange(libHYRL_gt_HeroYrelAvengingWrathOn, null, "YrelAvengingWrathChannelBuff", c_unitBehaviorChangeActivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Yrel - Avenging Wrath - Player Clicked
//--------------------------------------------------------------------------------------------------
bool libHYRL_gt_HeroYrelAvengingWrathPlayerClicked_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_playerID;
    unit lv_heroUnit;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_playerID = EventPlayer();
    lv_heroUnit = libGame_gv_players[lv_playerID].lv_heroUnit;

    // Conditions
    if (testConds) {
        if (!((EventKeyAlt() == false))) {
            return false;
        }
    }

    // Actions
    if (!runActions) {
        return true;
    }

    if ((UnitHasBehavior2(lv_heroUnit, "YrelAvengingWrathChannelBuff") == true)) {
        UnitIssueOrder(lv_heroUnit, OrderTargetingPoint(AbilityCommand("YrelAvengingWrath", 0), Point(EventMouseClickedPosXWorld(), EventMouseClickedPosYWorld())), c_orderQueueReplace);
        return true;
    }

    if ((UnitGetType(libGame_gv_players[lv_playerID].lv_heroUnit) == "HeroAbathur") && (UnitHasBehavior2(libGame_gv_players[lv_playerID].lv_activeVehicle, "YrelAvengingWrathChannelBuff") == true)) {
        UnitIssueOrder(libGame_gv_players[lv_playerID].lv_activeVehicle, OrderTargetingPoint(AbilityCommand("YrelAvengingWrath", 0), Point(EventMouseClickedPosXWorld(), EventMouseClickedPosYWorld())), c_orderQueueReplace);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libHYRL_gt_HeroYrelAvengingWrathPlayerClicked_Init () {
    libHYRL_gt_HeroYrelAvengingWrathPlayerClicked = TriggerCreate("libHYRL_gt_HeroYrelAvengingWrathPlayerClicked_Func");
    TriggerEnable(libHYRL_gt_HeroYrelAvengingWrathPlayerClicked, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Yrel - Avenging Wrath - Off
//--------------------------------------------------------------------------------------------------
bool libHYRL_gt_HeroYrelAvengingWrathOff_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libHYRL_gv_heroYrelAvengingWrathPlayerCount -= 1;
    if ((libHYRL_gv_heroYrelAvengingWrathPlayerCount < 0)) {
        libHYRL_gv_heroYrelAvengingWrathPlayerCount = 0;
    }

    if ((libHYRL_gv_heroYrelAvengingWrathPlayerCount == 0)) {
        TriggerEnable(libHYRL_gt_HeroYrelAvengingWrathPlayerClicked, false);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libHYRL_gt_HeroYrelAvengingWrathOff_Init () {
    libHYRL_gt_HeroYrelAvengingWrathOff = TriggerCreate("libHYRL_gt_HeroYrelAvengingWrathOff_Func");
    TriggerEnable(libHYRL_gt_HeroYrelAvengingWrathOff, false);
    TriggerAddEventUnitBehaviorChange(libHYRL_gt_HeroYrelAvengingWrathOff, null, "YrelAvengingWrathChannelBuff", c_unitBehaviorChangeDeactivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Yrel - Ardent Defender - On
//--------------------------------------------------------------------------------------------------
bool libHYRL_gt_HeroYrelArdentDefenderOn_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libHYRL_gv_heroYrelArdentDefenderPlayerCount += 1;
    TriggerEnable(libHYRL_gt_HeroYrelArdentDefenderDamageTracker, true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHYRL_gt_HeroYrelArdentDefenderOn_Init () {
    libHYRL_gt_HeroYrelArdentDefenderOn = TriggerCreate("libHYRL_gt_HeroYrelArdentDefenderOn_Func");
    TriggerEnable(libHYRL_gt_HeroYrelArdentDefenderOn, false);
    TriggerAddEventUnitBehaviorChange(libHYRL_gt_HeroYrelArdentDefenderOn, null, "YrelArdentDefenderDamageTracker", c_unitBehaviorChangeActivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Yrel - Ardent Defender - Damage Tracker
//--------------------------------------------------------------------------------------------------
bool libHYRL_gt_HeroYrelArdentDefenderDamageTracker_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_yrelUnit;
    int lv_yrelPlayer;
    fixed lv_damageAmount;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_yrelUnit = EventUnit();
    lv_yrelPlayer = UnitGetOwner(lv_yrelUnit);

    // Conditions
    if (testConds) {
        if (!((EventUnitDamageEffect() != "HeroGenericDummyInterruptDamage"))) {
            return false;
        }

        if (!((UnitHasBehavior2(lv_yrelUnit, "YrelArdentDefenderDamageTracker") == true))) {
            return false;
        }

        if (!(((lv_yrelPlayer >= 1) && (lv_yrelPlayer <= libCore_gv_bALMaxPlayers)))) {
            return false;
        }
    }

    // Actions
    if (!runActions) {
        return true;
    }

    libHYRL_gv_heroYrelArdentDefenderDamageConversionScale = CatalogFieldValueGetAsFixed(c_gameCatalogEffect, "YrelArdentDefenderDamageConversionScaleDummyModifyUnit", "XP", lv_yrelPlayer);
    lv_damageAmount = (libHYRL_gv_heroYrelArdentDefenderDamageConversionScale * (EventUnitDamageAmount() + EventUnitDamageBehaviorShield()));
    CatalogFieldValueSetFixed(c_gameCatalogEffect, "YrelArdentDefenderCreateHealer", "RechargeVitalRate", lv_yrelPlayer, lv_damageAmount);
    UnitCreateEffectUnit(lv_yrelUnit, "YrelArdentDefenderHealSet", lv_yrelUnit);
    if ((PlayerHasTalent(lv_yrelPlayer, "YrelArdentDefenderWordOfGlory") == true)) {
        CatalogFieldValueSetFixed(c_gameCatalogEffect, "YrelArdentDefenderWordOfGloryCreateHealer", "RechargeVitalRate", lv_yrelPlayer, lv_damageAmount);
        UnitCreateEffectUnit(lv_yrelUnit, "YrelArdentDefenderWordOfGlorySearchArea", lv_yrelUnit);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libHYRL_gt_HeroYrelArdentDefenderDamageTracker_Init () {
    libHYRL_gt_HeroYrelArdentDefenderDamageTracker = TriggerCreate("libHYRL_gt_HeroYrelArdentDefenderDamageTracker_Func");
    TriggerEnable(libHYRL_gt_HeroYrelArdentDefenderDamageTracker, false);
    TriggerAddDamageEvent(libHYRL_gt_HeroYrelArdentDefenderDamageTracker, null, "HeroYrel", c_unitDamageTypeAny, c_unitDamageEither, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Yrel - Ardent Defender - Off
//--------------------------------------------------------------------------------------------------
bool libHYRL_gt_HeroYrelArdentDefenderOff_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libHYRL_gv_heroYrelArdentDefenderPlayerCount -= 1;
    if ((libHYRL_gv_heroYrelArdentDefenderPlayerCount < 0)) {
        libHYRL_gv_heroYrelArdentDefenderPlayerCount = 0;
    }

    if ((libHYRL_gv_heroYrelArdentDefenderPlayerCount == 0)) {
        TriggerEnable(libHYRL_gt_HeroYrelArdentDefenderDamageTracker, false);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libHYRL_gt_HeroYrelArdentDefenderOff_Init () {
    libHYRL_gt_HeroYrelArdentDefenderOff = TriggerCreate("libHYRL_gt_HeroYrelArdentDefenderOff_Func");
    TriggerEnable(libHYRL_gt_HeroYrelArdentDefenderOff, false);
    TriggerAddEventUnitBehaviorChange(libHYRL_gt_HeroYrelArdentDefenderOff, null, "YrelArdentDefenderDamageTracker", c_unitBehaviorChangeDeactivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Yrel - Bubble Hearth - Overlay On
//--------------------------------------------------------------------------------------------------
bool libHYRL_gt_HeroYrelBubbleHearthOverlayOn_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_unit;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_unit = EventUnit();

    // Conditions
    if (testConds) {
        if (!((UnitIsAlive(lv_unit) == true))) {
            return false;
        }

        if (!((UnitTestState(lv_unit, c_unitStateHallucination) == false))) {
            return false;
        }

        if (!((UnitHasBehavior2(lv_unit, "HeroGenericIgnoreFullscreenOverlay") == false))) {
            return false;
        }
    }

    // Actions
    if (!runActions) {
        return true;
    }

    libUIUI_gf_FullscreenOverlayAddItemForPlayer(EventPlayer(), libUIUI_ge_FullscreenOverlayPriorities_Invulnerable, "Cutscenes\\GameUI_InvulnerableOverlay.StormCutscene", EventUnitBehavior());
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHYRL_gt_HeroYrelBubbleHearthOverlayOn_Init () {
    libHYRL_gt_HeroYrelBubbleHearthOverlayOn = TriggerCreate("libHYRL_gt_HeroYrelBubbleHearthOverlayOn_Func");
    TriggerEnable(libHYRL_gt_HeroYrelBubbleHearthOverlayOn, false);
    TriggerAddEventUnitBehaviorChange(libHYRL_gt_HeroYrelBubbleHearthOverlayOn, null, "YrelBubbleHearthChannelBuff", c_unitBehaviorChangeActivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Yrel - Bubble Hearth - Overlay Off
//--------------------------------------------------------------------------------------------------
bool libHYRL_gt_HeroYrelBubbleHearthOverlayOff_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((UnitHasBehavior2(EventUnit(), "HeroGenericIgnoreFullscreenOverlay") == false))) {
            return false;
        }
    }

    // Actions
    if (!runActions) {
        return true;
    }

    libUIUI_gf_FullscreenOverlayRemoveItemFromQueueForPlayer(EventPlayer(), "Cutscenes\\GameUI_InvulnerableOverlay.StormCutscene", EventUnitBehavior());
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHYRL_gt_HeroYrelBubbleHearthOverlayOff_Init () {
    libHYRL_gt_HeroYrelBubbleHearthOverlayOff = TriggerCreate("libHYRL_gt_HeroYrelBubbleHearthOverlayOff_Func");
    TriggerEnable(libHYRL_gt_HeroYrelBubbleHearthOverlayOff, false);
    TriggerAddEventUnitBehaviorChange(libHYRL_gt_HeroYrelBubbleHearthOverlayOff, null, "YrelBubbleHearthChannelBuff", c_unitBehaviorChangeDestroy);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Yrel - Bubble Hearth - Hearthstone Talent Disable Check
//--------------------------------------------------------------------------------------------------
bool libHYRL_gt_HeroYrelBubbleHearthHearthstoneTalentDisableCheck_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((UnitGetType(EventUnit()) == "HeroYrel"))) {
            return false;
        }
    }

    // Actions
    if (!runActions) {
        return true;
    }

    SetTalentEnabled("YrelBubbleHearth", false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHYRL_gt_HeroYrelBubbleHearthHearthstoneTalentDisableCheck_Init () {
    libHYRL_gt_HeroYrelBubbleHearthHearthstoneTalentDisableCheck = TriggerCreate("libHYRL_gt_HeroYrelBubbleHearthHearthstoneTalentDisableCheck_Func");
    TriggerEnable(libHYRL_gt_HeroYrelBubbleHearthHearthstoneTalentDisableCheck, false);
    TriggerAddEventUnitBehaviorChange(libHYRL_gt_HeroYrelBubbleHearthHearthstoneTalentDisableCheck, null, "HearthstonePermanentDisableAbilityBuff", c_unitBehaviorChangeActivate);
}

void libHYRL_InitTriggers () {
    libHYRL_gt_HeroYrelHeroSpawned_Init();
    libHYRL_gt_HeroYrelAbathurUltimateEvolutionHeroCopied_Init();
    libHYRL_gt_HeroYrelGameOverEvent_Init();
    libHYRL_gt_HeroYrelVindicationOn_Init();
    libHYRL_gt_HeroYrelVindicationPlayerClicked_Init();
    libHYRL_gt_HeroYrelVindicationOff_Init();
    libHYRL_gt_HeroYrelRighteousHammerOn_Init();
    libHYRL_gt_HeroYrelRighteousHammerPlayerClicked_Init();
    libHYRL_gt_HeroYrelRighteousHammerOff_Init();
    libHYRL_gt_HeroYrelAvengingWrathOn_Init();
    libHYRL_gt_HeroYrelAvengingWrathPlayerClicked_Init();
    libHYRL_gt_HeroYrelAvengingWrathOff_Init();
    libHYRL_gt_HeroYrelArdentDefenderOn_Init();
    libHYRL_gt_HeroYrelArdentDefenderDamageTracker_Init();
    libHYRL_gt_HeroYrelArdentDefenderOff_Init();
    libHYRL_gt_HeroYrelBubbleHearthOverlayOn_Init();
    libHYRL_gt_HeroYrelBubbleHearthOverlayOff_Init();
    libHYRL_gt_HeroYrelBubbleHearthHearthstoneTalentDisableCheck_Init();
}

//--------------------------------------------------------------------------------------------------
// Library Initialization
//--------------------------------------------------------------------------------------------------
bool libHYRL_InitLib_completed = false;

void libHYRL_InitLib () {
    if (libHYRL_InitLib_completed) {
        return;
    }

    libHYRL_InitLib_completed = true;

    libHYRL_InitLibraries();
    libHYRL_InitVariables();
    libHYRL_InitTriggers();
}