PTR build 2.57.1.98674_ptr. Go to the live site.

mods/heromods/dehaka.stormmod/base.stormdata/libhdeh.galaxy

libhdeh.galaxy
include "TriggerLibs/NativeLib"
include "TriggerLibs/HeroesLib"
include "TriggerLibs/GameLib"
include "TriggerLibs/AILib"
include "TriggerLibs/UILib"

include "LibHDEH_h"

//--------------------------------------------------------------------------------------------------
// Library: Dehaka
//--------------------------------------------------------------------------------------------------
// External Library Initialization
void libHDEH_InitLibraries () {
    libNtve_InitVariables();
    libCore_InitVariables();
    libGame_InitVariables();
    libAIAI_InitVariables();
    libUIUI_InitVariables();
}

// Variable Initialization
bool libHDEH_InitVariables_completed = false;

void libHDEH_InitVariables () {
    int init_i;

    if (libHDEH_InitVariables_completed) {
        return;
    }

    libHDEH_InitVariables_completed = true;

    for (init_i = 0; init_i <= libCore_gv_bALMaxPlayers; init_i += 1) {
        libHDEH_gv_brushStalkerPingTextLockoutTimer[init_i] = TimerCreate();
    }
    for (init_i = 0; init_i <= libCore_gv_bALMaxPlayers; init_i += 1) {
        libHDEH_gv_brushStalkerPings[init_i] = c_invalidPingId;
    }
    for (init_i = 0; init_i <= libCore_gv_bALMaxPlayers; init_i += 1) {
        libHDEH_gv_heroDehakaEssenceCollectionMaxStackCount[init_i] = 50;
    }
    for (init_i = 0; init_i <= libCore_gv_bALMaxPlayers; init_i += 1) {
        libHDEH_gv_heroDehakaIsolationBackupVisionGroups[init_i] = UnitGroupEmpty();
    }
    libHDEH_gv_heroDehakaTalentEnhancedAgilityMaxTokenStackCount = CatalogFieldValueGetAsInt(c_gameCatalogBehavior, "DehakaEssenceCollectionEnhancedAgilityQuestToken", "Max", 0);
    libHDEH_gv_heroDehakaTalentTissueRegenerationMaxTokenStackCount = CatalogFieldValueGetAsInt(c_gameCatalogBehavior, "DehakaEssenceCollectionTissueRegenerationQuestToken", "Max", 0);
    libHDEH_gv_heroDehakaTalentEssenceDevourerMaxTokenCount = CatalogFieldValueGetAsInt(c_gameCatalogBehavior, "DehakaEssenceCollectionEssenceDevourerQuestToken", "Max", 0);
}

// Functions
void libHDEH_gf_HeroDehakaIncrementHeroCountFunction () {
    // Automatic Variable Declarations
    // Implementation
    libHDEH_gv_heroDehakaTriggerRegistrationVariable += 1;
    if ((libHDEH_gv_heroDehakaTriggerRegistrationVariable == 1)) {
        TriggerEnable(libHDEH_gt_HeroDehakaBurrowOverlayOn, true);
        TriggerEnable(libHDEH_gt_HeroDehakaBurrowOverlayOff, true);
        TriggerEnable(libHDEH_gt_HeroDehakaBrushStalkerStart, true);
        TriggerEnable(libHDEH_gt_HeroDehakaBrushStalkerEnd, true);
        TriggerEnable(libHDEH_gt_HeroDehakaBrushStalkerPing, true);
        TriggerEnable(libHDEH_gt_HeroDehakaAdaptationDamageTracker, true);
        TriggerEnable(libHDEH_gt_HeroDehakaAdaptationHeal, true);
        TriggerEnable(libHDEH_gt_HeroDehakaAdaptationHealPreviewDamageTracker, true);
        TriggerEnable(libHDEH_gt_HeroDehakaAdaptationHealPreviewCatalog, true);
        TriggerEnable(libHDEH_gt_HeroDehakaEssenceCollectionHeal, true);
        TriggerEnable(libHDEH_gt_HeroDehakaEssenceCollectionHeroTakedown, true);
        TriggerEnable(libHDEH_gt_HeroDehakaEssenceCollectionNPCKill, true);
        TriggerEnable(libHDEH_gt_HeroDehakaEssenceCollectionEssenceClawsProc, true);
        TriggerEnable(libHDEH_gt_HeroDehakaTalentResetClearStacks, true);
        TriggerEnable(libHDEH_gt_HeroDehakaMultiHeroIsolationController, true);
        TriggerEnable(libHDEH_gt_HeroDehakaApplyAllyVisionSuppression, true);
        TriggerEnable(libHDEH_gt_HeroDehakaRemoveAllyVisionSuppression, true);
        TriggerEnable(libHDEH_gt_HeroDehakaApplyDragCameraLock, true);
        TriggerEnable(libHDEH_gt_HeroDehakaDragMovespeedUpdate, true);
        TriggerEnable(libHDEH_gt_HeroDehakaTalentEssenceDevourer, true);
        TriggerEnable(libHDEH_gt_HeroDehakaHeroStalkerTalentDarkSwarmProc, true);
    }

}

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

    if ((libHDEH_gv_heroDehakaTriggerRegistrationVariable == 0)) {
        TriggerEnable(libHDEH_gt_HeroDehakaBurrowOverlayOn, false);
        TriggerEnable(libHDEH_gt_HeroDehakaBurrowOverlayOff, false);
        TriggerEnable(libHDEH_gt_HeroDehakaBrushStalkerStart, false);
        TriggerEnable(libHDEH_gt_HeroDehakaBrushStalkerEnd, false);
        TriggerEnable(libHDEH_gt_HeroDehakaBrushStalkerPing, false);
        TriggerEnable(libHDEH_gt_HeroDehakaAdaptationDamageTracker, false);
        TriggerEnable(libHDEH_gt_HeroDehakaAdaptationHeal, false);
        TriggerEnable(libHDEH_gt_HeroDehakaAdaptationHealPreviewDamageTracker, false);
        TriggerEnable(libHDEH_gt_HeroDehakaAdaptationHealPreviewCatalog, false);
        TriggerEnable(libHDEH_gt_HeroDehakaEssenceCollectionHeal, false);
        TriggerEnable(libHDEH_gt_HeroDehakaEssenceCollectionHeroTakedown, false);
        TriggerEnable(libHDEH_gt_HeroDehakaEssenceCollectionNPCKill, false);
        TriggerEnable(libHDEH_gt_HeroDehakaEssenceCollectionEssenceClawsProc, false);
        TriggerEnable(libHDEH_gt_HeroDehakaTalentResetClearStacks, false);
        TriggerEnable(libHDEH_gt_HeroDehakaMultiHeroIsolationController, false);
        TriggerEnable(libHDEH_gt_HeroDehakaApplyAllyVisionSuppression, false);
        TriggerEnable(libHDEH_gt_HeroDehakaRemoveAllyVisionSuppression, false);
        TriggerEnable(libHDEH_gt_HeroDehakaApplyDragCameraLock, false);
        TriggerEnable(libHDEH_gt_HeroDehakaDragMovespeedUpdate, false);
        TriggerEnable(libHDEH_gt_HeroDehakaTalentEssenceDevourer, false);
        TriggerEnable(libHDEH_gt_HeroDehakaHeroStalkerTalentDarkSwarmProc, false);
    }

}

void libHDEH_gf_HeroDehakaTalentEnhancedAgilityAddEssenceForPlayer (int lp_playerNumber, int lp_essenceCollectedAmount) {
    // Variable Declarations
    unit lv_dehakaUnit;
    int lv_currentScoreValue;
    int lv_newScoreValue;
    int lv_questStackstoAdd;
    int lv_remainderEssence;

    // Automatic Variable Declarations
    int autoF8A4A058_n;
    int autoF8A4A058_i;

    // Variable Initialization
    lv_dehakaUnit = libGame_gv_players[lp_playerNumber].lv_heroUnit;
    lv_currentScoreValue = PlayerScoreValueGetAsInt(lp_playerNumber, "DehakaEssenceCollectionMuscularAugementationCount");
    lv_newScoreValue = (lv_currentScoreValue + lp_essenceCollectedAmount);
    lv_questStackstoAdd = (lv_newScoreValue / libHDEH_gv_heroDehakaTalentEnhancedAgilityEssencePerStack);
    lv_remainderEssence = ModI(lv_newScoreValue, libHDEH_gv_heroDehakaTalentEnhancedAgilityEssencePerStack);

    // Implementation
    if ((((PlayerHasTalent(lp_playerNumber, "DehakaEssenceCollectionTalentEnhancedAgility") == true) && (UnitBehaviorCount(lv_dehakaUnit, "DehakaEssenceCollectionEnhancedAgilityQuestToken") == libHDEH_gv_heroDehakaTalentEnhancedAgilityMaxTokenStackCount)) || (PlayerHasTalent(lp_playerNumber, "DehakaEssenceCollectionTalentEnhancedAgility") == false))) {
        return ;
    }

    if ((lv_questStackstoAdd > 0)) {
        autoF8A4A058_n = lv_questStackstoAdd;
        for (autoF8A4A058_i = 1; autoF8A4A058_i <= autoF8A4A058_n; autoF8A4A058_i += 1) {
            UnitCreateEffectUnit(lv_dehakaUnit, "DehakaEssenceCollectionEnhancedAgilityTalentQuestProgressModifyTokenCount", lv_dehakaUnit);
        }
        if ((UnitBehaviorCount(lv_dehakaUnit, "DehakaEssenceCollectionEnhancedAgilityQuestToken") == libHDEH_gv_heroDehakaTalentEnhancedAgilityMaxTokenStackCount)) {
            libGame_gf_ScoreValuesReportIntegerValueAndLog(lp_playerNumber, "DehakaEssenceCollectionMuscularAugementationCount", 0);
            return ;
        }

    }

    libGame_gf_ScoreValuesReportIntegerValueAndLog(lp_playerNumber, "DehakaEssenceCollectionMuscularAugementationCount", lv_remainderEssence);
}

void libHDEH_gf_HeroDehakaTalentTissueRegenerationAddEssenceForPlayer (int lp_playerNumber, int lp_essenceCollectedAmount) {
    // Variable Declarations
    unit lv_dehakaUnit;
    int lv_currentScoreValue;
    int lv_newScoreValue;
    int lv_questStackstoAdd;
    int lv_remainderEssence;

    // Automatic Variable Declarations
    int autoD706C9E8_n;
    int autoD706C9E8_i;

    // Variable Initialization
    lv_dehakaUnit = libGame_gv_players[lp_playerNumber].lv_heroUnit;
    lv_currentScoreValue = PlayerScoreValueGetAsInt(lp_playerNumber, "DehakaEssenceCollectionTissueRegenerationCount");
    lv_newScoreValue = (lv_currentScoreValue + lp_essenceCollectedAmount);
    lv_questStackstoAdd = (lv_newScoreValue / libHDEH_gv_heroDehakaTalentTissueRegenerationEssencePerStack);
    lv_remainderEssence = ModI(lv_newScoreValue, libHDEH_gv_heroDehakaTalentTissueRegenerationEssencePerStack);

    // Implementation
    if ((((PlayerHasTalent(lp_playerNumber, "DehakaEssenceCollectionTalentTissueRegeneration") == true) && (UnitBehaviorCount(lv_dehakaUnit, "DehakaEssenceCollectionTissueRegenerationQuestToken") == libHDEH_gv_heroDehakaTalentTissueRegenerationMaxTokenStackCount)) || (PlayerHasTalent(lp_playerNumber, "DehakaEssenceCollectionTalentTissueRegeneration") == false))) {
        return ;
    }

    if ((lv_questStackstoAdd > 0)) {
        autoD706C9E8_n = lv_questStackstoAdd;
        for (autoD706C9E8_i = 1; autoD706C9E8_i <= autoD706C9E8_n; autoD706C9E8_i += 1) {
            UnitCreateEffectUnit(lv_dehakaUnit, "TalentEssenceCollectionTissueRegenerationTalentQuestProgressModifyTokenCount", lv_dehakaUnit);
            UnitCreateEffectUnit(lv_dehakaUnit, "DehakaEssenceCollectionEssenceDevourerQuestIncrementToken", lv_dehakaUnit);
            libHDEH_gv_heroDehakaEssenceCollectionMaxStackCount[lp_playerNumber] += 1;
        }
        if ((UnitBehaviorCount(lv_dehakaUnit, "DehakaEssenceCollectionTissueRegenerationQuestToken") == libHDEH_gv_heroDehakaTalentTissueRegenerationMaxTokenStackCount)) {
            libGame_gf_ScoreValuesReportIntegerValueAndLog(lp_playerNumber, "DehakaEssenceCollectionTissueRegenerationCount", 0);
            return ;
        }

    }

    libGame_gf_ScoreValuesReportIntegerValueAndLog(lp_playerNumber, "DehakaEssenceCollectionTissueRegenerationCount", lv_remainderEssence);
}

// Triggers
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Dehaka - Burrow Overlay On
//--------------------------------------------------------------------------------------------------
bool libHDEH_gt_HeroDehakaBurrowOverlayOn_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_unit;

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

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

    if ((UnitIsAlive(lv_unit) == true) && (UnitTestState(lv_unit, c_unitStateHallucination) == false) && (UnitHasBehavior2(lv_unit, "HeroGenericIgnoreFullscreenOverlay") == false)) {
        libUIUI_gf_FullscreenOverlayAddItemForPlayer(UnitGetOwner(lv_unit), libUIUI_ge_FullscreenOverlayPriorities_Stasis, "Cutscenes\\GameUI_DehakaBurrowOverlay.StormCutscene", EventUnitBehavior());
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libHDEH_gt_HeroDehakaBurrowOverlayOn_Init () {
    libHDEH_gt_HeroDehakaBurrowOverlayOn = TriggerCreate("libHDEH_gt_HeroDehakaBurrowOverlayOn_Func");
    TriggerEnable(libHDEH_gt_HeroDehakaBurrowOverlayOn, false);
    TriggerAddEventUnitBehaviorChange(libHDEH_gt_HeroDehakaBurrowOverlayOn, null, "DehakaBurrowChannel", c_unitBehaviorChangeActivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Dehaka - Burrow Overlay Off
//--------------------------------------------------------------------------------------------------
bool libHDEH_gt_HeroDehakaBurrowOverlayOff_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_unit;

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

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

    if ((UnitHasBehavior2(lv_unit, "HeroGenericIgnoreFullscreenOverlay") == false)) {
        libUIUI_gf_FullscreenOverlayRemoveItemFromQueueForPlayer(UnitGetOwner(lv_unit), "Cutscenes\\GameUI_DehakaBurrowOverlay.StormCutscene", EventUnitBehavior());
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libHDEH_gt_HeroDehakaBurrowOverlayOff_Init () {
    libHDEH_gt_HeroDehakaBurrowOverlayOff = TriggerCreate("libHDEH_gt_HeroDehakaBurrowOverlayOff_Func");
    TriggerEnable(libHDEH_gt_HeroDehakaBurrowOverlayOff, false);
    TriggerAddEventUnitBehaviorChange(libHDEH_gt_HeroDehakaBurrowOverlayOff, null, "DehakaBurrowChannel", c_unitBehaviorChangeDestroy);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Dehaka - Brush Stalker Start
//--------------------------------------------------------------------------------------------------
bool libHDEH_gt_HeroDehakaBrushStalkerStart_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    PlayerAddLabel(EventPlayer(), "Brushstalker");
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHDEH_gt_HeroDehakaBrushStalkerStart_Init () {
    libHDEH_gt_HeroDehakaBrushStalkerStart = TriggerCreate("libHDEH_gt_HeroDehakaBrushStalkerStart_Func");
    TriggerEnable(libHDEH_gt_HeroDehakaBrushStalkerStart, false);
    TriggerAddEventTargetModeUpdate(libHDEH_gt_HeroDehakaBrushStalkerStart, c_playerAny, AbilityCommand("DehakaBrushstalker", 0), c_targetModeStateOn);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Dehaka - Brush Stalker End
//--------------------------------------------------------------------------------------------------
bool libHDEH_gt_HeroDehakaBrushStalkerEnd_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    PlayerRemoveLabel(EventPlayer(), "Brushstalker");
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHDEH_gt_HeroDehakaBrushStalkerEnd_Init () {
    libHDEH_gt_HeroDehakaBrushStalkerEnd = TriggerCreate("libHDEH_gt_HeroDehakaBrushStalkerEnd_Func");
    TriggerEnable(libHDEH_gt_HeroDehakaBrushStalkerEnd, false);
    TriggerAddEventTargetModeUpdate(libHDEH_gt_HeroDehakaBrushStalkerEnd, c_playerAny, AbilityCommand("DehakaBrushstalker", 0), c_targetModeStateOff);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Dehaka - Brush Stalker Ping
//--------------------------------------------------------------------------------------------------
bool libHDEH_gt_HeroDehakaBrushStalkerPing_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_dehakaPlayer;
    playergroup lv_alliedPlayers;
    point lv_location;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_dehakaPlayer = EventPlayer();
    lv_alliedPlayers = PlayerGroupEmpty();
    lv_location = EventUnitTargetPoint();

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

    if ((TimerGetRemaining(libUIUI_gv_pingInputSuppressionTimer[lv_dehakaPlayer]) > 0.0)) {
        return true;
    }

    if ((TimerGetRemaining(libUIUI_gv_pingLockoutTimer[lv_dehakaPlayer]) > 0.0)) {
        return true;
    }

    libUIUI_gf_PingIncrementPingCountAndManageTimersForPlayer(lv_dehakaPlayer);
    lv_alliedPlayers = libGame_gf_PlayersOnTeamHeroes(libGame_gf_TeamNumberOfPlayer(lv_dehakaPlayer), false);
    libNtve_gf_CreatePingFacingAngleWithType(lv_alliedPlayers, "DehakaBrushStalkerShrubClusterModelMiniMap", lv_location, Color(0.00, 5.49, 73.33), 3.0, 270.0, -1, -1);
    if ((libGame_gv_players[lv_dehakaPlayer].lv_activeVehicle != null)) {
        UnitCreateEffectPoint(libGame_gv_players[lv_dehakaPlayer].lv_activeVehicle, "DehakaBrushstalkerDummyPing", lv_location);
    }
    else {
        UnitCreateEffectPoint(libGame_gv_players[lv_dehakaPlayer].lv_heroUnit, "DehakaBrushstalkerDummyPing", lv_location);
    }
    TextExpressionSetToken("Param/Expression/lib_HDEH_5664274E", "A", UnitTypeGetName(UnitGetType(libGame_gv_players[lv_dehakaPlayer].lv_heroUnit)));
    TextTagCreate(TextExpressionAssemble("Param/Expression/lib_HDEH_5664274E"), 24, lv_location, 2.0, true, false, libGame_gf_PlayersOnTeamHeroes(libGame_gf_TeamNumberOfPlayer(lv_dehakaPlayer), false));
    TextTagSetTime(TextTagLastCreated(), c_textTagTimeDuration, 3.5);
    libHDEH_gv_brushStalkerPings[lv_dehakaPlayer] = PingLastCreated();
    PingSetScale(PingLastCreated(), 0.2);
    if ((TimerGetRemaining(libHDEH_gv_brushStalkerPingTextLockoutTimer[lv_dehakaPlayer]) > 0.0)) {
    }
    else {
        TextExpressionSetToken("Param/Expression/lib_HDEH_3B30129B", "A", StringExternal("Param/Value/lib_HDEH_B0846FDD"));
        UIDisplayMessage(lv_alliedPlayers, c_messageAreaChat, TextExpressionAssemble("Param/Expression/lib_HDEH_3B30129B"));
        TimerStart(libHDEH_gv_brushStalkerPingTextLockoutTimer[lv_dehakaPlayer], 10.0, false, c_timeGame);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHDEH_gt_HeroDehakaBrushStalkerPing_Init () {
    libHDEH_gt_HeroDehakaBrushStalkerPing = TriggerCreate("libHDEH_gt_HeroDehakaBrushStalkerPing_Func");
    TriggerEnable(libHDEH_gt_HeroDehakaBrushStalkerPing, false);
    TriggerAddEventUnitAbility(libHDEH_gt_HeroDehakaBrushStalkerPing, null, AbilityCommand("DehakaBrushstalker", 0), c_abilEffectStageCast, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Dehaka - Adaptation Damage Tracker
//--------------------------------------------------------------------------------------------------
bool libHDEH_gt_HeroDehakaAdaptationDamageTracker_Func (bool testConds, bool runActions) {
    // Variable Declarations
    fixed lv_damageAmount;
    unit lv_dehakaUnit;
    int lv_dehakaPlayer;

    // Automatic Variable Declarations
    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((UnitHasBehavior2(EventUnit(), "DehakaAdaptationDamageTrackerBehavior") == true))) {
            return false;
        }
    }

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

    lv_dehakaUnit = EventUnit();
    lv_dehakaPlayer = UnitGetOwner(lv_dehakaUnit);
    if (((lv_dehakaPlayer > libCore_gv_bALMaxPlayers) || (lv_dehakaPlayer <= 0))) {
        return true;
    }

    lv_damageAmount = (EventUnitDamageAmount() + EventUnitDamageBehaviorShield());
    if ((PlayerHasTalent(lv_dehakaPlayer, "DehakaAdaptationChangeIsSurvivalTalent") != true)) {
        lv_damageAmount = (lv_damageAmount * libHDEH_gv_heroDehakaAdaptationBaseHealMod);
    }
    else {
        lv_damageAmount = (lv_damageAmount * libHDEH_gv_heroDehakaAdaptationTalentedHealMod);
    }
    libHDEH_gv_heroDehakaAdaptationCombinedHeal[lv_dehakaPlayer] += lv_damageAmount;
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHDEH_gt_HeroDehakaAdaptationDamageTracker_Init () {
    libHDEH_gt_HeroDehakaAdaptationDamageTracker = TriggerCreate("libHDEH_gt_HeroDehakaAdaptationDamageTracker_Func");
    TriggerEnable(libHDEH_gt_HeroDehakaAdaptationDamageTracker, false);
    TriggerAddDamageEvent(libHDEH_gt_HeroDehakaAdaptationDamageTracker, null, "HeroDehaka", c_unitDamageTypeAny, c_unitDamageEither, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Dehaka - Adaptation Heal
//--------------------------------------------------------------------------------------------------
bool libHDEH_gt_HeroDehakaAdaptationHeal_Func (bool testConds, bool runActions) {
    // Variable Declarations
    fixed lv_healAmount;
    unit lv_dehakaUnit;
    int lv_dehakaPlayer;

    // Automatic Variable Declarations
    // Variable Initialization

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

    lv_dehakaUnit = EventUnit();
    lv_dehakaPlayer = UnitGetOwner(lv_dehakaUnit);
    lv_healAmount = libHDEH_gv_heroDehakaAdaptationCombinedHeal[lv_dehakaPlayer];
    CatalogFieldValueSetFixed(c_gameCatalogEffect, "DehakaAdaptationCreateHealer", "RechargeVitalRate", lv_dehakaPlayer, lv_healAmount);
    CatalogFieldValueSet(c_gameCatalogEffect, "DehakaAdaptationDummyTrackerCreateHealer", "RechargeVitalRate", lv_dehakaPlayer, "0");
    UnitCreateEffectUnit(lv_dehakaUnit, "DehakaAdaptationApplyHealTrackerBehavior", lv_dehakaUnit);
    libHDEH_gv_heroDehakaAdaptationCombinedHeal[lv_dehakaPlayer] = 0.0;
    libHDEH_gv_heroDehakaAdaptationHealPreviewCombinedDamage[lv_dehakaPlayer] = 0.0;
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHDEH_gt_HeroDehakaAdaptationHeal_Init () {
    libHDEH_gt_HeroDehakaAdaptationHeal = TriggerCreate("libHDEH_gt_HeroDehakaAdaptationHeal_Func");
    TriggerEnable(libHDEH_gt_HeroDehakaAdaptationHeal, false);
    TriggerAddEventUnitBehaviorChange(libHDEH_gt_HeroDehakaAdaptationHeal, null, "DehakaAdaptationDamageTrackerBehavior", c_unitBehaviorChangeDeactivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Dehaka - Adaptation Heal Preview Damage Tracker
//--------------------------------------------------------------------------------------------------
bool libHDEH_gt_HeroDehakaAdaptationHealPreviewDamageTracker_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_dehakaUnit;
    int lv_dehakaPlayer;
    unit lv_damagingUnit;
    fixed lv_incomingDamage;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_dehakaUnit = EventUnit();
    lv_dehakaPlayer = UnitGetOwner(lv_dehakaUnit);
    lv_damagingUnit = EventUnitDamageSourceUnit();

    // Conditions
    if (testConds) {
        if (!((lv_dehakaPlayer <= libCore_gv_bALMaxPlayers))) {
            return false;
        }

        if (!((UnitHasBehavior2(lv_dehakaUnit, "DehakaAdaptationDamageTrackerBehavior") == true))) {
            return false;
        }
    }

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

    lv_incomingDamage = (EventUnitDamageAmount() + EventUnitDamageBehaviorShield());
    if ((PlayerHasTalent(lv_dehakaPlayer, "DehakaAdaptationChangeIsSurvivalTalent") != true)) {
        lv_incomingDamage = (lv_incomingDamage * libHDEH_gv_heroDehakaAdaptationBaseHealMod);
    }
    else {
        lv_incomingDamage = (lv_incomingDamage * libHDEH_gv_heroDehakaAdaptationTalentedHealMod);
    }
    libHDEH_gv_heroDehakaAdaptationHealPreviewCombinedDamage[lv_dehakaPlayer] += lv_incomingDamage;
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHDEH_gt_HeroDehakaAdaptationHealPreviewDamageTracker_Init () {
    libHDEH_gt_HeroDehakaAdaptationHealPreviewDamageTracker = TriggerCreate("libHDEH_gt_HeroDehakaAdaptationHealPreviewDamageTracker_Func");
    TriggerEnable(libHDEH_gt_HeroDehakaAdaptationHealPreviewDamageTracker, false);
    TriggerAddDamageEvent(libHDEH_gt_HeroDehakaAdaptationHealPreviewDamageTracker, null, "HeroDehaka", c_unitDamageTypeAny, c_unitDamageEither, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Dehaka - Adaptation Heal Preview Catalog
//--------------------------------------------------------------------------------------------------
bool libHDEH_gt_HeroDehakaAdaptationHealPreviewCatalog_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_dehakaUnit;
    int lv_dehakaPlayer;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_dehakaUnit = EventPlayerEffectUsedUnit(c_effectUnitCaster);
    lv_dehakaPlayer = UnitGetOwner(lv_dehakaUnit);

    // Conditions
    if (testConds) {
        if (!((UnitGetType(lv_dehakaUnit) == "HeroDehaka"))) {
            return false;
        }

        if (!((UnitHasBehavior2(lv_dehakaUnit, "DehakaAdaptationDamageTrackerBehavior") == true))) {
            return false;
        }
    }

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

    CatalogFieldValueSetFixed(c_gameCatalogEffect, "DehakaAdaptationDummyTrackerCreateHealer", "RechargeVitalRate", lv_dehakaPlayer, libHDEH_gv_heroDehakaAdaptationHealPreviewCombinedDamage[lv_dehakaPlayer]);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHDEH_gt_HeroDehakaAdaptationHealPreviewCatalog_Init () {
    libHDEH_gt_HeroDehakaAdaptationHealPreviewCatalog = TriggerCreate("libHDEH_gt_HeroDehakaAdaptationHealPreviewCatalog_Func");
    TriggerEnable(libHDEH_gt_HeroDehakaAdaptationHealPreviewCatalog, false);
    TriggerAddEventPlayerEffectUsed(libHDEH_gt_HeroDehakaAdaptationHealPreviewCatalog, c_playerAny, "DehakaAdaptationDummySet");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Dehaka - Essence Collection - Heal
//--------------------------------------------------------------------------------------------------
bool libHDEH_gt_HeroDehakaEssenceCollectionHeal_Func (bool testConds, bool runActions) {
    // Variable Declarations
    fixed lv_healAmount;
    unit lv_dehakaUnit;
    int lv_dehakaPlayer;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_dehakaUnit = EventPlayerEffectUsedUnit(c_effectUnitCaster);

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

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

    lv_dehakaPlayer = UnitGetOwner(lv_dehakaUnit);
    lv_healAmount = (((libHDEH_gv_heroDehakaEssenceCollectionMaxStackCount[lv_dehakaPlayer] - UnitGetChargeUsed(lv_dehakaUnit, "Abil/DehakaEssenceCollection")) * CatalogFieldValueGetAsFixed(c_gameCatalogEffect, "DehakaEssenceCollectionCreateHealer", "RechargeVitalRate", lv_dehakaPlayer)) / CatalogFieldValueGetAsFixed(c_gameCatalogBehavior, "DehakaEssenceCollectionHealBehavior", "PeriodCount", lv_dehakaPlayer));
    libGame_gf_ScoreValuesReportRealValueAndLog(lv_dehakaPlayer, "DehakaEssenceCollectionHealing", 0.0);
    CatalogFieldValueSetFixed(c_gameCatalogEffect, "DehakaEssenceCollectionCatalogCreateHealer", "RechargeVitalRate", lv_dehakaPlayer, lv_healAmount);
    UnitCreateEffectUnit(lv_dehakaUnit, "DehakaEssenceCollectionRemoveChargeCountPersistent", lv_dehakaUnit);
    UnitCreateEffectUnit(lv_dehakaUnit, "DehakaEssenceCollectionPrimalRageTalentResetToken", lv_dehakaUnit);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHDEH_gt_HeroDehakaEssenceCollectionHeal_Init () {
    libHDEH_gt_HeroDehakaEssenceCollectionHeal = TriggerCreate("libHDEH_gt_HeroDehakaEssenceCollectionHeal_Func");
    TriggerEnable(libHDEH_gt_HeroDehakaEssenceCollectionHeal, false);
    TriggerAddEventPlayerEffectUsed(libHDEH_gt_HeroDehakaEssenceCollectionHeal, c_playerAny, "DehakaEssenceCollectionInitialAmountSwitch");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Dehaka - Essence Collection - Hero Takedown
//--------------------------------------------------------------------------------------------------
bool libHDEH_gt_HeroDehakaEssenceCollectionHeroTakedown_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_player;
    unit lv_dehakaUnit;
    bool lv_hasStalkerTalent;
    int lv_currentTalentScoreValue;
    int lv_stacksToAdd;
    int lv_leftOverStacks;
    fixed lv_healAmount;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_player = libGame_gf_HeroParticipatedInTakedownKillingPlayer();

    // Conditions
    if (testConds) {
        if (!((libGame_gv_players[lv_player].lv_isDead == false))) {
            return false;
        }

        if (!(((UnitHasBehavior2(libGame_gv_players[lv_player].lv_heroUnit, "DehakaEssenceCollectionCarryBehavior") == true) || (UnitHasBehavior2(libGame_gv_players[lv_player].lv_activeVehicle, "DehakaEssenceCollectionCarryBehavior") == true)))) {
            return false;
        }
    }

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

    if ((UnitGetType(libGame_gv_players[lv_player].lv_heroUnit) == "HeroDehaka")) {
        lv_dehakaUnit = libGame_gv_players[lv_player].lv_heroUnit;
    }
    else {
        lv_dehakaUnit = libGame_gv_players[lv_player].lv_activeVehicle;
    }
    lv_hasStalkerTalent = PlayerHasTalent(lv_player, "DehakaEssenceCollectionTalentHeroStalker");
    if ((lv_hasStalkerTalent == true)) {
        lv_stacksToAdd = libHDEH_gv_heroDehakaEssenceCollectionHeroTakedownCountHeroStalker;
    }
    else {
        lv_stacksToAdd = libHDEH_gv_heroDehakaEssenceCollectionHeroTakedownCount;
    }
    UnitCreateEffectUnit(lv_dehakaUnit, "DehakaEssenceCollectionPCKillAddChargeCountModifyUnit", lv_dehakaUnit);
    UnitCreateEffectUnit(lv_dehakaUnit, "DehakaEssenceCollectionPCKillPrimalRageTalentModifyToken", lv_dehakaUnit);
    UnitCreateEffectUnit(lv_dehakaUnit, "DehakaEssenceCollectionHeroTargetLaunchMissile", libGame_gf_HeroParticipatedInTakedownKilledHero());
    libHDEH_gf_HeroDehakaTalentEnhancedAgilityAddEssenceForPlayer(lv_player, lv_stacksToAdd);
    libHDEH_gf_HeroDehakaTalentTissueRegenerationAddEssenceForPlayer(lv_player, lv_stacksToAdd);
    libGame_gf_ScoreValuesReportRealValueAndLog(lv_player, "DehakaEssenceCollectionHealing", ((libHDEH_gv_heroDehakaEssenceCollectionMaxStackCount[lv_player] - UnitGetChargeUsed(lv_dehakaUnit, "Abil/DehakaEssenceCollection")) * CatalogFieldValueGetAsFixed(c_gameCatalogEffect, "DehakaEssenceCollectionCreateHealer", "RechargeVitalRate", lv_player)));
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHDEH_gt_HeroDehakaEssenceCollectionHeroTakedown_Init () {
    libHDEH_gt_HeroDehakaEssenceCollectionHeroTakedown = TriggerCreate("libHDEH_gt_HeroDehakaEssenceCollectionHeroTakedown_Func");
    TriggerEnable(libHDEH_gt_HeroDehakaEssenceCollectionHeroTakedown, false);
    libGame_gf_HeroParticipatedInTakedown(libHDEH_gt_HeroDehakaEssenceCollectionHeroTakedown);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Dehaka - Essence Collection - NPC Kill
//--------------------------------------------------------------------------------------------------
bool libHDEH_gt_HeroDehakaEssenceCollectionNPCKill_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_player;
    unit lv_nPC;
    string lv_nPCType;
    unit lv_dehakaUnit;
    int lv_currentTalentScoreValue;
    int lv_stacksToAdd;
    int lv_leftOverStacks;
    fixed lv_healAmount;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_player = libGame_gf_HeroParticipatedInNPCTakedownKillingPlayer();
    lv_nPC = libGame_gf_HeroParticipatedInNPCTakedownMinion();

    // Conditions
    if (testConds) {
        if (!((libGame_gv_players[lv_player].lv_isDead == false))) {
            return false;
        }

        if (!(((UnitHasBehavior2(libGame_gv_players[lv_player].lv_heroUnit, "DehakaEssenceCollectionCarryBehavior") == true) || (UnitHasBehavior2(libGame_gv_players[lv_player].lv_activeVehicle, "DehakaEssenceCollectionCarryBehavior") == true)))) {
            return false;
        }
    }

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

    lv_nPCType = UnitGetType(lv_nPC);
    if (((UnitTypeTestAttribute(lv_nPCType, c_unitAttributeStructure) == true) || (UnitTypeTestAttribute(lv_nPCType, c_unitAttributeMerc) == true) || (UnitTypeTestAttribute(lv_nPCType, c_unitAttributeCreep) == true) || (UnitTypeTestAttribute(lv_nPCType, c_unitAttributeSummoned) == true))) {
        return true;
    }

    if ((UnitGetType(libGame_gv_players[lv_player].lv_heroUnit) == "HeroDehaka")) {
        lv_dehakaUnit = libGame_gv_players[lv_player].lv_heroUnit;
    }
    else {
        lv_dehakaUnit = libGame_gv_players[lv_player].lv_activeVehicle;
    }
    if ((PlayerHasTalent(UnitGetOwner(lv_dehakaUnit), "DehakaEssenceCollectionOneWhoCollectsTalent") == true)) {
        lv_stacksToAdd = libHDEH_gv_heroDehakaEssenceCollectionNPCTakedownCountOneWhoCollects;
    }
    else {
        lv_stacksToAdd = libHDEH_gv_heroDehakaEssenceCollectionNPCTakedownCount;
    }
    UnitCreateEffectUnit(lv_dehakaUnit, "DehakaEssenceCollectionNPCKillAddChargeCountModifyUnit", lv_dehakaUnit);
    UnitCreateEffectUnit(lv_dehakaUnit, "DehakaEssenceCollectionNPCKillPrimalRageTalentModifyToken", lv_dehakaUnit);
    UnitCreateEffectUnit(lv_dehakaUnit, "DehakaEssenceCollectionNonHeroTargetLaunchMissile", lv_nPC);
    libHDEH_gf_HeroDehakaTalentEnhancedAgilityAddEssenceForPlayer(lv_player, lv_stacksToAdd);
    libHDEH_gf_HeroDehakaTalentTissueRegenerationAddEssenceForPlayer(lv_player, lv_stacksToAdd);
    libGame_gf_ScoreValuesReportRealValueAndLog(lv_player, "DehakaEssenceCollectionHealing", ((libHDEH_gv_heroDehakaEssenceCollectionMaxStackCount[lv_player] - UnitGetChargeUsed(lv_dehakaUnit, "Abil/DehakaEssenceCollection")) * CatalogFieldValueGetAsFixed(c_gameCatalogEffect, "DehakaEssenceCollectionCreateHealer", "RechargeVitalRate", lv_player)));
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHDEH_gt_HeroDehakaEssenceCollectionNPCKill_Init () {
    libHDEH_gt_HeroDehakaEssenceCollectionNPCKill = TriggerCreate("libHDEH_gt_HeroDehakaEssenceCollectionNPCKill_Func");
    TriggerEnable(libHDEH_gt_HeroDehakaEssenceCollectionNPCKill, false);
    libGame_gf_HeroParticipatedInNPCTakedown(libHDEH_gt_HeroDehakaEssenceCollectionNPCKill);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Dehaka - Essence Collection - Essence Claws Proc
//--------------------------------------------------------------------------------------------------
bool libHDEH_gt_HeroDehakaEssenceCollectionEssenceClawsProc_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_target;
    unit lv_caster;
    int lv_player;
    int lv_currentTalentScoreValue;
    int lv_stacksToAdd;
    int lv_leftOverStacks;
    fixed lv_healAmount;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_target = EventPlayerEffectUsedUnit(c_effectUnitTarget);
    lv_caster = EventPlayerEffectUsedUnit(c_effectUnitCaster);
    lv_player = UnitGetOwner(lv_caster);
    lv_stacksToAdd = (CatalogFieldValueGetAsInt(c_gameCatalogEffect, "DehakaEssenceCollectionEssenceClawsTalentModifyChargeCount", "Cost[" + IntToString(0) + "].ChargeCountUse", 0) * -1);

    // Conditions
    if (testConds) {
        if (!((libGame_gv_players[lv_player].lv_isDead == false))) {
            return false;
        }
    }

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

    UnitCreateEffectUnit(lv_caster, "DehakaEssenceCollectionEssenceClawsTalentModifyChargeCount", lv_caster);
    UnitCreateEffectUnit(lv_caster, "DehakaEssenceCollectionEssenceClawsPrimalRageTalentModifyToken", lv_caster);
    UnitCreateEffectUnit(lv_caster, "DehakaEssenceCollectionHeroTargetLaunchMissile", lv_target);
    libHDEH_gf_HeroDehakaTalentEnhancedAgilityAddEssenceForPlayer(lv_player, lv_stacksToAdd);
    libHDEH_gf_HeroDehakaTalentTissueRegenerationAddEssenceForPlayer(lv_player, lv_stacksToAdd);
    libGame_gf_ScoreValuesReportRealValueAndLog(lv_player, "DehakaEssenceCollectionHealing", ((libHDEH_gv_heroDehakaEssenceCollectionMaxStackCount[lv_player] - UnitGetChargeUsed(lv_caster, "Abil/DehakaEssenceCollection")) * CatalogFieldValueGetAsFixed(c_gameCatalogEffect, "DehakaEssenceCollectionCreateHealer", "RechargeVitalRate", lv_player)));
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHDEH_gt_HeroDehakaEssenceCollectionEssenceClawsProc_Init () {
    libHDEH_gt_HeroDehakaEssenceCollectionEssenceClawsProc = TriggerCreate("libHDEH_gt_HeroDehakaEssenceCollectionEssenceClawsProc_Func");
    TriggerEnable(libHDEH_gt_HeroDehakaEssenceCollectionEssenceClawsProc, false);
    TriggerAddEventPlayerEffectUsed(libHDEH_gt_HeroDehakaEssenceCollectionEssenceClawsProc, c_playerAny, "DehakaEssenceCollectionEssenceClawsTalentDummy");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Dehaka Multi-Hero Isolation Controller
//--------------------------------------------------------------------------------------------------
bool libHDEH_gt_HeroDehakaMultiHeroIsolationController_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_dehakaPlayer;
    int lv_isolatedPlayer;
    unitgroup lv_isolatedPlayerVisionGroup;
    unit lv_targethero;
    int lv_targetplayer;
    playergroup lv_AllyPlayerGroup;
    int lv_p;

    // Automatic Variable Declarations
    playergroup auto5022FEEB_g;

    // Variable Initialization
    lv_isolatedPlayer = UnitGetOwner(EventUnit());
    lv_isolatedPlayerVisionGroup = UnitGroupEmpty();
    lv_targethero = EventUnit();
    lv_targetplayer = UnitGetOwner(EventUnit());
    lv_AllyPlayerGroup = PlayerGroupEmpty();

    // Conditions
    if (testConds) {
        if (!((UnitHasBehavior2(EventUnit(), "DehakaIsolationVisionSource") == true))) {
            return false;
        }

        if (!((lv_isolatedPlayer > 0))) {
            return false;
        }

        if (!((lv_isolatedPlayer < libCore_gv_bALMaxPlayers))) {
            return false;
        }
    }

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

    lv_dehakaPlayer = UnitBehaviorEffectPlayer(EventUnit(), "DehakaIsolationVisionSource", c_effectPlayerCaster, 0);
    UnitGroupRemove(libHDEH_gv_heroDehakaIsolationBackupVisionGroups[lv_targetplayer], EventUnit());
    if ((UnitGroupCount(libHDEH_gv_heroDehakaIsolationBackupVisionGroups[lv_targetplayer], c_unitCountAlive) == 0)) {
        libGame_gf_ShareUnshareVisionOfAlliesForPlayer(false, lv_targetplayer);
        lv_AllyPlayerGroup = libGame_gf_AlliedPlayerGroupOfPlayer(lv_targetplayer);
        auto5022FEEB_g = lv_AllyPlayerGroup;
        lv_p = -1;
        while (true) {
            	lv_p = PlayerGroupNextPlayer(auto5022FEEB_g, lv_p);
            	if (lv_p<0) { break; }
            	PlayerSetAlliance(lv_p, c_allianceIdSeekHelp, lv_targetplayer, false);
            PlayerSetAlliance(lv_p, c_allianceIdGiveHelp, lv_targetplayer, false);
        }
        VisRevealerEnable(libGame_gv_baseRevealers[lv_targetplayer], false);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libHDEH_gt_HeroDehakaMultiHeroIsolationController_Init () {
    libHDEH_gt_HeroDehakaMultiHeroIsolationController = TriggerCreate("libHDEH_gt_HeroDehakaMultiHeroIsolationController_Func");
    TriggerEnable(libHDEH_gt_HeroDehakaMultiHeroIsolationController, false);
    TriggerAddEventUnitDied(libHDEH_gt_HeroDehakaMultiHeroIsolationController, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Dehaka Apply Ally Vision Suppression
//--------------------------------------------------------------------------------------------------
bool libHDEH_gt_HeroDehakaApplyAllyVisionSuppression_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_dehakaPlayer;
    unit lv_targethero;
    int lv_targetplayer;
    unitgroup lv_targetPlayerVisionGroup;
    playergroup lv_AllyPlayerGroup;
    int lv_p;

    // Automatic Variable Declarations
    unitgroup auto2ADD902E_g;
    int auto2ADD902E_u;
    unit auto2ADD902E_var;
    playergroup autoE8915A40_g;

    // Variable Initialization
    lv_dehakaPlayer = UnitBehaviorEffectPlayer(EventUnit(), "DehakaIsolationVisionReduction", c_effectPlayerSource, 0);
    lv_targethero = EventUnit();
    lv_targetplayer = UnitGetOwner(lv_targethero);
    lv_targetPlayerVisionGroup = UnitGroupEmpty();
    lv_AllyPlayerGroup = PlayerGroupEmpty();

    // Conditions
    if (testConds) {
        if (!((lv_targetplayer > 0))) {
            return false;
        }

        if (!((lv_targetplayer <= libCore_gv_bALMaxPlayers))) {
            return false;
        }

        if (!((lv_dehakaPlayer > 0))) {
            return false;
        }

        if (!((lv_dehakaPlayer <= libCore_gv_bALMaxPlayers))) {
            return false;
        }

        if (!((UnitTypeTestAttribute(UnitGetType(lv_targethero), c_unitAttributeHeroic) == true))) {
            return false;
        }

        if (!(((lv_targethero == libGame_gv_players[lv_targetplayer].lv_heroUnit) || (lv_targethero == libAIAI_gv_aIHeroes[lv_targetplayer].lv_currentHeroUnit) || (UnitGetType(lv_targethero) == "HeroBaleog") || (UnitGetType(lv_targethero) == "HeroErik") || (UnitGetType(lv_targethero) == "HeroOlaf") || (UnitGetType(lv_targethero) == "HeroChenEarth") || (UnitGetType(lv_targethero) == "HeroChenFire") || (UnitGetType(lv_targethero) == "HeroChenStorm")))) {
            return false;
        }
    }

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

    libHDEH_gv_heroDehakaIsolationBackupVisionGroups[lv_targetplayer] = UnitGroupEmpty();
    libHDEH_gv_heroDehakaActiveIsolationTargets += 1;
    auto2ADD902E_g = UnitGroup(null, lv_targetplayer, RegionEntireMap(), UnitFilter((1 << c_targetFilterHeroic), 0, (1 << c_targetFilterAlly) | (1 << c_targetFilterNeutral) | (1 << c_targetFilterEnemy) | (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)) | (1 << (c_targetFilterInvulnerable - 32))), 0);
    auto2ADD902E_u = UnitGroupCount(auto2ADD902E_g, c_unitCountAll);
    for (;; auto2ADD902E_u -= 1) {
        auto2ADD902E_var = UnitGroupUnitFromEnd(auto2ADD902E_g, auto2ADD902E_u);
        if (auto2ADD902E_var == null) { break; }
        if ((UnitHasBehavior2(auto2ADD902E_var, "DehakaIsolationVisionReduction") == false) && (UnitGetType(auto2ADD902E_var) != "NovaHoloCloneCloaked") && (UnitGetType(auto2ADD902E_var) != "NovaHoloClone") && (UnitGetType(auto2ADD902E_var) != "RexxarMisha")) {
            UnitGroupAdd(libHDEH_gv_heroDehakaIsolationBackupVisionGroups[lv_targetplayer], auto2ADD902E_var);
            UnitBehaviorAdd(auto2ADD902E_var, "DehakaIsolationVisionSource", libGame_gv_players[lv_dehakaPlayer].lv_heroUnit, 1);
        }

    }
    if ((UnitGroupCount(libHDEH_gv_heroDehakaIsolationBackupVisionGroups[lv_targetplayer], c_unitCountAlive) == 0)) {
        libGame_gf_ShareUnshareVisionOfAlliesForPlayer(false, lv_targetplayer);
        lv_AllyPlayerGroup = libGame_gf_AlliedPlayerGroupOfPlayer(lv_targetplayer);
        autoE8915A40_g = lv_AllyPlayerGroup;
        lv_p = -1;
        while (true) {
            	lv_p = PlayerGroupNextPlayer(autoE8915A40_g, lv_p);
            	if (lv_p<0) { break; }
            	PlayerSetAlliance(lv_p, c_allianceIdSeekHelp, lv_targetplayer, false);
            PlayerSetAlliance(lv_p, c_allianceIdGiveHelp, lv_targetplayer, false);
        }
        VisRevealerEnable(libGame_gv_baseRevealers[lv_targetplayer], false);
    }

    if ((libHDEH_gv_heroDehakaActiveIsolationTargets > 0) && (UnitGroupCount(libHDEH_gv_heroDehakaIsolationBackupVisionGroups[lv_targetplayer], c_unitCountAlive) > 0)) {
        TriggerEnable(libHDEH_gt_HeroDehakaMultiHeroIsolationController, true);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libHDEH_gt_HeroDehakaApplyAllyVisionSuppression_Init () {
    libHDEH_gt_HeroDehakaApplyAllyVisionSuppression = TriggerCreate("libHDEH_gt_HeroDehakaApplyAllyVisionSuppression_Func");
    TriggerEnable(libHDEH_gt_HeroDehakaApplyAllyVisionSuppression, false);
    TriggerAddEventUnitBehaviorChange(libHDEH_gt_HeroDehakaApplyAllyVisionSuppression, null, "DehakaIsolationVisionReduction", c_unitBehaviorChangeActivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Dehaka Remove Ally Vision Suppression
//--------------------------------------------------------------------------------------------------
bool libHDEH_gt_HeroDehakaRemoveAllyVisionSuppression_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_targetHero;
    int lv_targetPlayer;
    playergroup lv_allyPlayerGroup;
    int lv_p;

    // Automatic Variable Declarations
    unitgroup auto3A703366_g;
    int auto3A703366_u;
    unit auto3A703366_var;
    playergroup auto2433D77C_g;

    // Variable Initialization
    lv_targetHero = EventUnit();
    lv_targetPlayer = UnitGetOwner(EventUnit());
    lv_allyPlayerGroup = PlayerGroupEmpty();

    // Conditions
    if (testConds) {
        if (!((UnitTypeTestAttribute(UnitGetType(EventUnit()), c_unitAttributeHeroic) == true))) {
            return false;
        }

        if (!((lv_targetPlayer > 0))) {
            return false;
        }

        if (!((lv_targetPlayer <= libCore_gv_bALMaxPlayers))) {
            return false;
        }
    }

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

    auto3A703366_g = libHDEH_gv_heroDehakaIsolationBackupVisionGroups[lv_targetPlayer];
    auto3A703366_u = UnitGroupCount(auto3A703366_g, c_unitCountAll);
    for (;; auto3A703366_u -= 1) {
        auto3A703366_var = UnitGroupUnitFromEnd(auto3A703366_g, auto3A703366_u);
        if (auto3A703366_var == null) { break; }
        UnitBehaviorRemove(auto3A703366_var, "DehakaIsolationVisionSource", 1);
    }
    if ((UnitHasBehaviorWithCategoryFlag(lv_targetHero, c_behaviorCategoryVisionRemoval) == false)) {
        libGame_gf_ShareUnshareVisionOfAlliesForPlayer(true, lv_targetPlayer);
        lv_allyPlayerGroup = libGame_gf_AlliedPlayerGroupOfPlayer(lv_targetPlayer);
        auto2433D77C_g = lv_allyPlayerGroup;
        lv_p = -1;
        while (true) {
            	lv_p = PlayerGroupNextPlayer(auto2433D77C_g, lv_p);
            	if (lv_p<0) { break; }
            	PlayerSetAlliance(lv_p, c_allianceIdSeekHelp, lv_targetPlayer, true);
            PlayerSetAlliance(lv_p, c_allianceIdGiveHelp, lv_targetPlayer, true);
        }
        VisRevealerEnable(libGame_gv_baseRevealers[lv_targetPlayer], true);
        libHDEH_gv_heroDehakaActiveIsolationTargets -= 1;
    }

    if ((libHDEH_gv_heroDehakaActiveIsolationTargets == 0)) {
        TriggerEnable(libHDEH_gt_HeroDehakaMultiHeroIsolationController, false);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libHDEH_gt_HeroDehakaRemoveAllyVisionSuppression_Init () {
    libHDEH_gt_HeroDehakaRemoveAllyVisionSuppression = TriggerCreate("libHDEH_gt_HeroDehakaRemoveAllyVisionSuppression_Func");
    TriggerEnable(libHDEH_gt_HeroDehakaRemoveAllyVisionSuppression, false);
    TriggerAddEventUnitBehaviorChange(libHDEH_gt_HeroDehakaRemoveAllyVisionSuppression, null, "DehakaIsolationVisionReduction", c_unitBehaviorChangeDeactivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Dehaka - Apply Drag - Camera Lock
//--------------------------------------------------------------------------------------------------
bool libHDEH_gt_HeroDehakaApplyDragCameraLock_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_targetPlayer;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_targetPlayer = UnitGetOwner(EventUnit());

    // Conditions
    if (testConds) {
        if (!(((UnitGetOwner(EventUnit()) >= 1) && (UnitGetOwner(EventUnit()) <= 10) && (EventUnit() == libGame_gv_players[lv_targetPlayer].lv_heroUnit) && (UnitIsAlive(EventUnit()) == true)))) {
            return false;
        }
    }

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

    libGame_gf_PlayerHeroDisplacementCameraLock(EventUnit(), EventUnitBehavior());
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHDEH_gt_HeroDehakaApplyDragCameraLock_Init () {
    libHDEH_gt_HeroDehakaApplyDragCameraLock = TriggerCreate("libHDEH_gt_HeroDehakaApplyDragCameraLock_Func");
    TriggerEnable(libHDEH_gt_HeroDehakaApplyDragCameraLock, false);
    TriggerAddEventUnitBehaviorChange(libHDEH_gt_HeroDehakaApplyDragCameraLock, null, "DehakaDragStun", c_unitBehaviorChangeActivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Dehaka - Drag - Movespeed Update
//--------------------------------------------------------------------------------------------------
bool libHDEH_gt_HeroDehakaDragMovespeedUpdate_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_draggedUnit;
    unit lv_dehakaUnit;
    int lv_dehakaPlayer;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_draggedUnit = EventUnit();
    lv_dehakaUnit = UnitBehaviorEffectUnit(lv_draggedUnit, EventUnitBehavior(), c_effectUnitCaster, 0);
    lv_dehakaPlayer = UnitGetOwner(lv_dehakaUnit);

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

    while ((UnitHasBehavior2(lv_draggedUnit, EventUnitBehavior()) == true)) {
        CatalogFieldValueSetFixed(c_gameCatalogBehavior, "DehakaDragStun", "Modification.MoveSpeedMinimum", lv_dehakaPlayer, UnitGetPropertyFixed(lv_dehakaUnit, c_unitPropMovementSpeed, c_unitPropCurrent));
        CatalogFieldValueSetFixed(c_gameCatalogBehavior, "DehakaDragStun", "Modification.MoveSpeedMaximum", lv_dehakaPlayer, UnitGetPropertyFixed(lv_dehakaUnit, c_unitPropMovementSpeed, c_unitPropCurrent));
        Wait(0.0625, c_timeGame);
    }
    CatalogFieldValueSetFixed(c_gameCatalogBehavior, "DehakaDragStun", "Modification.MoveSpeedMinimum", lv_dehakaPlayer, CatalogFieldValueGetAsFixed(c_gameCatalogUnit, "HeroDehaka", "Speed", c_playerAny));
    CatalogFieldValueSetFixed(c_gameCatalogBehavior, "DehakaDragStun", "Modification.MoveSpeedMaximum", lv_dehakaPlayer, CatalogFieldValueGetAsFixed(c_gameCatalogUnit, "HeroDehaka", "Speed", c_playerAny));
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHDEH_gt_HeroDehakaDragMovespeedUpdate_Init () {
    libHDEH_gt_HeroDehakaDragMovespeedUpdate = TriggerCreate("libHDEH_gt_HeroDehakaDragMovespeedUpdate_Func");
    TriggerEnable(libHDEH_gt_HeroDehakaDragMovespeedUpdate, false);
    TriggerAddEventUnitBehaviorChange(libHDEH_gt_HeroDehakaDragMovespeedUpdate, null, "DehakaDragStun", c_unitBehaviorChangeActivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Dehaka - Talent Reset Clear Stacks
//--------------------------------------------------------------------------------------------------
bool libHDEH_gt_HeroDehakaTalentResetClearStacks_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_player;
    unit lv_dehakaUnit;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_player = libGame_gf_HeroRespecsTalentsPlayer();

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

    if ((UnitGetType(libGame_gv_players[lv_player].lv_heroUnit) == "HeroDehaka")) {
        lv_dehakaUnit = libGame_gv_players[lv_player].lv_heroUnit;
    }
    else {
        lv_dehakaUnit = libGame_gv_players[lv_player].lv_activeVehicle;
    }
    libGame_gf_ScoreValuesReportIntegerValueAndLog(lv_player, "DehakaEssenceCollectionMuscularAugementationCount", 0);
    libGame_gf_ScoreValuesReportIntegerValueAndLog(lv_player, "DehakaEssenceCollectionTissueRegenerationCount", 0);
    libHDEH_gv_heroDehakaEssenceCollectionMaxStackCount[libGame_gf_HeroRespecsTalentsPlayer()] = 50;
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHDEH_gt_HeroDehakaTalentResetClearStacks_Init () {
    libHDEH_gt_HeroDehakaTalentResetClearStacks = TriggerCreate("libHDEH_gt_HeroDehakaTalentResetClearStacks_Func");
    TriggerEnable(libHDEH_gt_HeroDehakaTalentResetClearStacks, false);
    libGame_gf_HeroRespecsTalents(libHDEH_gt_HeroDehakaTalentResetClearStacks);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Dehaka - Talent - Essence Devourer
//--------------------------------------------------------------------------------------------------
bool libHDEH_gt_HeroDehakaTalentEssenceDevourer_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_player;
    unit lv_dehakaUnit;
    int lv_currentTalentScoreValue;
    int lv_leftOverStacks;
    int lv_essenceStacksfromGlobes;

    // Automatic Variable Declarations
    // Variable Initialization

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

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

    lv_player = EventPlayerEffectUsedUnitOwner(c_effectPlayerCaster);
    lv_dehakaUnit = libGame_gv_players[lv_player].lv_heroUnit;
    if ((UnitIsAlive(libGame_gv_players[lv_player].lv_heroUnit) == true) && (UnitHasBehavior2(libGame_gv_players[lv_player].lv_heroUnit, "DehakaEssenceCollectionEssenceDevourerQuestToken") == true)) {
        lv_essenceStacksfromGlobes = AbsI(CatalogFieldValueGetAsInt(c_gameCatalogEffect, "DehakaEssenceCollectionEssenceDevourerTalentModifyChargeCount", "Cost[" + IntToString(0) + "].ChargeCountUse", lv_player));
        UnitCreateEffectUnit(lv_dehakaUnit, "DehakaEssenceCollectionTissueRegenerationProcSet", lv_dehakaUnit);
        libHDEH_gf_HeroDehakaTalentEnhancedAgilityAddEssenceForPlayer(lv_player, lv_essenceStacksfromGlobes);
        libHDEH_gf_HeroDehakaTalentTissueRegenerationAddEssenceForPlayer(lv_player, lv_essenceStacksfromGlobes);
    }

    libGame_gf_ScoreValuesReportRealValueAndLog(lv_player, "DehakaEssenceCollectionHealing", ((libHDEH_gv_heroDehakaEssenceCollectionMaxStackCount[lv_player] - UnitGetChargeUsed(lv_dehakaUnit, "Abil/DehakaEssenceCollection")) * CatalogFieldValueGetAsFixed(c_gameCatalogEffect, "DehakaEssenceCollectionCreateHealer", "RechargeVitalRate", lv_player)));
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHDEH_gt_HeroDehakaTalentEssenceDevourer_Init () {
    libHDEH_gt_HeroDehakaTalentEssenceDevourer = TriggerCreate("libHDEH_gt_HeroDehakaTalentEssenceDevourer_Func");
    TriggerEnable(libHDEH_gt_HeroDehakaTalentEssenceDevourer, false);
    TriggerAddEventPlayerEffectUsed(libHDEH_gt_HeroDehakaTalentEssenceDevourer, c_playerAny, "RegenGlobeImpactSet");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Dehaka - Hero Stalker Talent Dark Swarm Proc
//--------------------------------------------------------------------------------------------------
bool libHDEH_gt_HeroDehakaHeroStalkerTalentDarkSwarmProc_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_player;
    unit lv_derhaka;
    int lv_essenceCollectedAmount;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_player = EventPlayerEffectUsedUnitOwner(c_effectPlayerCaster);
    lv_derhaka = libGame_gv_players[lv_player].lv_heroUnit;
    lv_essenceCollectedAmount = 1;

    // Conditions
    if (testConds) {
        if (!((lv_player > 0))) {
            return false;
        }

        if (!((lv_player <= libCore_gv_bALMaxPlayers))) {
            return false;
        }
    }

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

    UnitCreateEffectUnit(lv_derhaka, "DehakaEssenceCollectionHeroStalkerAddChargeCountModifyUnit", lv_derhaka);
    UnitCreateEffectUnit(lv_derhaka, "DehakaEssenceCollectionDarkSwarmHeroStalkerPrimalRageTalentModifyToken", lv_derhaka);
    libHDEH_gf_HeroDehakaTalentEnhancedAgilityAddEssenceForPlayer(lv_player, lv_essenceCollectedAmount);
    libHDEH_gf_HeroDehakaTalentTissueRegenerationAddEssenceForPlayer(lv_player, lv_essenceCollectedAmount);
    libGame_gf_ScoreValuesReportRealValueAndLog(lv_player, "DehakaEssenceCollectionHealing", ((libHDEH_gv_heroDehakaEssenceCollectionMaxStackCount[lv_player] - UnitGetChargeUsed(lv_derhaka, "Abil/DehakaEssenceCollection")) * CatalogFieldValueGetAsFixed(c_gameCatalogEffect, "DehakaEssenceCollectionCreateHealer", "RechargeVitalRate", lv_player)));
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHDEH_gt_HeroDehakaHeroStalkerTalentDarkSwarmProc_Init () {
    libHDEH_gt_HeroDehakaHeroStalkerTalentDarkSwarmProc = TriggerCreate("libHDEH_gt_HeroDehakaHeroStalkerTalentDarkSwarmProc_Func");
    TriggerEnable(libHDEH_gt_HeroDehakaHeroStalkerTalentDarkSwarmProc, false);
    TriggerAddEventPlayerEffectUsed(libHDEH_gt_HeroDehakaHeroStalkerTalentDarkSwarmProc, c_playerAny, "DehakaEssenceCollectionHeroStalkerAddChargeCountDummy");
}

void libHDEH_InitTriggers () {
    libHDEH_gt_HeroDehakaBurrowOverlayOn_Init();
    libHDEH_gt_HeroDehakaBurrowOverlayOff_Init();
    libHDEH_gt_HeroDehakaBrushStalkerStart_Init();
    libHDEH_gt_HeroDehakaBrushStalkerEnd_Init();
    libHDEH_gt_HeroDehakaBrushStalkerPing_Init();
    libHDEH_gt_HeroDehakaAdaptationDamageTracker_Init();
    libHDEH_gt_HeroDehakaAdaptationHeal_Init();
    libHDEH_gt_HeroDehakaAdaptationHealPreviewDamageTracker_Init();
    libHDEH_gt_HeroDehakaAdaptationHealPreviewCatalog_Init();
    libHDEH_gt_HeroDehakaEssenceCollectionHeal_Init();
    libHDEH_gt_HeroDehakaEssenceCollectionHeroTakedown_Init();
    libHDEH_gt_HeroDehakaEssenceCollectionNPCKill_Init();
    libHDEH_gt_HeroDehakaEssenceCollectionEssenceClawsProc_Init();
    libHDEH_gt_HeroDehakaMultiHeroIsolationController_Init();
    libHDEH_gt_HeroDehakaApplyAllyVisionSuppression_Init();
    libHDEH_gt_HeroDehakaRemoveAllyVisionSuppression_Init();
    libHDEH_gt_HeroDehakaApplyDragCameraLock_Init();
    libHDEH_gt_HeroDehakaDragMovespeedUpdate_Init();
    libHDEH_gt_HeroDehakaTalentResetClearStacks_Init();
    libHDEH_gt_HeroDehakaTalentEssenceDevourer_Init();
    libHDEH_gt_HeroDehakaHeroStalkerTalentDarkSwarmProc_Init();
}

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

void libHDEH_InitLib () {
    if (libHDEH_InitLib_completed) {
        return;
    }

    libHDEH_InitLib_completed = true;

    libHDEH_InitLibraries();
    libHDEH_InitVariables();
    libHDEH_InitTriggers();
}