PTR build 2.57.1.98674_ptr. Go to the live site.

mods/heromods/medivh.stormmod/base.stormdata/libhmdv.galaxy

libhmdv.galaxy
include "TriggerLibs/NativeLib"
include "TriggerLibs/HeroesLib"
include "TriggerLibs/GameLib"
include "TriggerLibs/MapMechanicsLib"
include "TriggerLibs/AILib"
include "TriggerLibs/UILib"

include "LibHMDV_h"

//--------------------------------------------------------------------------------------------------
// Library: Medivh
//--------------------------------------------------------------------------------------------------
// External Library Initialization
void libHMDV_InitLibraries () {
    libNtve_InitVariables();
    libCore_InitVariables();
    libGame_InitVariables();
    libMapM_InitVariables();
    libAIAI_InitVariables();
    libUIUI_InitVariables();
}

// Variable Initialization
bool libHMDV_InitVariables_completed = false;

void libHMDV_InitVariables () {
    int init_i;

    if (libHMDV_InitVariables_completed) {
        return;
    }

    libHMDV_InitVariables_completed = true;

    for (init_i = 0; init_i <= libCore_gv_bALMaxPlayers; init_i += 1) {
        libHMDV_gv_medivhForceofWillPlayerGroup[init_i] = PlayerGroupEmpty();
    }
    libHMDV_gv_medivhForceOfWillBaseHealMod = 0.2;
    libHMDV_gv_medivhForceOfWillReabsorptionTalentHealMod = 0.7;
}

// Functions
void libHMDV_gf_HeroMedivhRavenFamiliartCloakController (unit lp_owningUnit, unit lp_ravenUnit) {
    // Automatic Variable Declarations
    // Implementation
    if (((UnitTestState(lp_owningUnit, c_unitStateCloaked) == true) || (UnitBehaviorCount(lp_owningUnit, "ShrubStatusController") == 1)) && (UnitHasBehavior2(lp_ravenUnit, "MedivhRavenFamiliarCloakingBehavior") == false) && (UnitHasBehavior2(lp_owningUnit, "AttackReveal") == false)) {
        UnitBehaviorAdd(lp_ravenUnit, "MedivhRavenFamiliarCloakingBehavior", lp_ravenUnit, 1);
    }
    else {
        if (((UnitBehaviorCount(lp_owningUnit, "ShrubStatusController") == 0) || (UnitHasBehavior2(lp_owningUnit, "AttackReveal") == true)) && (UnitTestState(lp_owningUnit, c_unitStateCloaked) == false) && (UnitHasBehavior2(lp_ravenUnit, "MedivhRavenFamiliarCloakingBehavior") == true)) {
            UnitBehaviorRemove(lp_ravenUnit, "MedivhRavenFamiliarCloakingBehavior", 1);
        }

    }
}

void libHMDV_gf_HeroMedivhIncrementHeroCountFunction () {
    // Automatic Variable Declarations
    // Implementation
    libHMDV_gv_heroMedivhTriggerRegistrationVariable += 1;
    if ((libHMDV_gv_heroMedivhTriggerRegistrationVariable == 1)) {
        TriggerEnable(libHMDV_gt_HeroMedivhLeyLineSealOverlayOn, true);
        TriggerEnable(libHMDV_gt_HeroMedivhRavenFamiliarSpawn, true);
        TriggerEnable(libHMDV_gt_HeroMedivhRavenFamiliarPostSpawnCloak, true);
        TriggerEnable(libHMDV_gt_HeroMedivhLeyLineSealOverlayOff, true);
        TriggerEnable(libHMDV_gt_HeroMedivhPortalCameraPan, false);
        TriggerEnable(libHMDV_gt_HeroMedivhPortalPortalMasterySelectionClamping, true);
        TriggerEnable(libHMDV_gt_HeroMedivhPortalPortalMasteryMorphBackToMedivh, true);
        TriggerEnable(libHMDV_gt_HeroMedivhForceofWillBehaviorResponses, true);
        TriggerEnable(libHMDV_gt_HeroMedivhForceofWillRemoveEarly, true);
        TriggerEnable(libHMDV_gt_HeroMedivhTransformRavenAfterPortToTown, true);
        TriggerEnable(libHMDV_gt_HeroMedivhTransformRavenMountingSpecialCase, true);
        TriggerEnable(libHMDV_gt_HeroMedivhTransformSwapToMedivh, true);
        TriggerEnable(libHMDV_gt_HeroAIAIMedivhRegisterPortalCast, true);
        TriggerEnable(libHMDV_gt_HeroAIMedivhHasCastRavenForm, true);
        TriggerEnable(libHMDV_gt_HeroAIMedivhHasLanded, true);
        TriggerEnable(libHMDV_gt_HeroAIAIMedivhUnregisterPortal, true);
        TriggerEnable(libHMDV_gt_HeroMedivhPortalMasteryCDR, true);
    }

}

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

    if ((libHMDV_gv_heroMedivhTriggerRegistrationVariable == 0)) {
        TriggerEnable(libHMDV_gt_HeroMedivhLeyLineSealOverlayOn, false);
        TriggerEnable(libHMDV_gt_HeroMedivhRavenFamiliarSpawn, false);
        TriggerEnable(libHMDV_gt_HeroMedivhRavenFamiliarPostSpawnCloak, false);
        TriggerEnable(libHMDV_gt_HeroMedivhLeyLineSealOverlayOff, false);
        TriggerEnable(libHMDV_gt_HeroMedivhPortalCameraPan, false);
        TriggerEnable(libHMDV_gt_HeroMedivhPortalPortalMasterySelectionClamping, false);
        TriggerEnable(libHMDV_gt_HeroMedivhPortalPortalMasteryMorphBackToMedivh, false);
        TriggerEnable(libHMDV_gt_HeroMedivhForceofWillBehaviorResponses, false);
        TriggerEnable(libHMDV_gt_HeroMedivhForceofWillRemoveEarly, false);
        TriggerEnable(libHMDV_gt_HeroMedivhTransformRavenAfterPortToTown, false);
        TriggerEnable(libHMDV_gt_HeroMedivhTransformRavenMountingSpecialCase, false);
        TriggerEnable(libHMDV_gt_HeroMedivhTransformSwapToMedivh, false);
        TriggerEnable(libHMDV_gt_HeroAIAIMedivhRegisterPortalCast, false);
        TriggerEnable(libHMDV_gt_HeroAIMedivhHasCastRavenForm, false);
        TriggerEnable(libHMDV_gt_HeroAIMedivhHasLanded, false);
        TriggerEnable(libHMDV_gt_HeroAIAIMedivhUnregisterPortal, false);
        TriggerEnable(libHMDV_gt_HeroMedivhPortalMasteryCDR, false);
    }

}

unitgroup libHMDV_gf_HeroAIMedivhFindPortalPair (int lp_player) {
    // Variable Declarations
    unitgroup lv_portalUnitGroup;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_portalUnitGroup = UnitGroupEmpty();

    // Implementation
    if ((lp_player >= 1) && (lp_player <= libCore_gv_bALMaxPlayers)) {
        return libNtve_gf_UnitsInRegionWithAllianceToPlayerMatchingCondition("MedivhPortal", "", "", lp_player, -1, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterSelf) | (1 << c_targetFilterNeutral) | (1 << c_targetFilterEnemy) | (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    }
    else {
        if ((libCore_gv_dEBUGDebuggingEnabled == true)) {
            TriggerDebugOutput(1, StringExternal("Param/Value/lib_HMDV_028E66AC"), true);
        }

        return null;
    }
}

// Triggers
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Medivh - Raven Familiar Spawn
//--------------------------------------------------------------------------------------------------
bool libHMDV_gt_HeroMedivhRavenFamiliarSpawn_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_raven;
    unit lv_player;
    int lv_targetPlayer;

    // Automatic Variable Declarations
    unitgroup auto8627E677_g;
    int auto8627E677_u;
    unit auto8627E677_var;

    // Variable Initialization
    lv_player = EventPlayerEffectUsedUnit(c_effectUnitTarget);
    lv_targetPlayer = UnitGetOwner(lv_player);

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

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

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

    auto8627E677_g = UnitGroup("MedivhPortalRavenFamiliar", lv_targetPlayer, RegionPlayableMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    auto8627E677_u = UnitGroupCount(auto8627E677_g, c_unitCountAll);
    for (;; auto8627E677_u -= 1) {
        auto8627E677_var = UnitGroupUnitFromEnd(auto8627E677_g, auto8627E677_u);
        if (auto8627E677_var == null) { break; }
        libHMDV_gf_HeroMedivhRavenFamiliartCloakController(lv_player, auto8627E677_var);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHMDV_gt_HeroMedivhRavenFamiliarSpawn_Init () {
    libHMDV_gt_HeroMedivhRavenFamiliarSpawn = TriggerCreate("libHMDV_gt_HeroMedivhRavenFamiliarSpawn_Func");
    TriggerEnable(libHMDV_gt_HeroMedivhRavenFamiliarSpawn, false);
    TriggerAddEventPlayerEffectUsed(libHMDV_gt_HeroMedivhRavenFamiliarSpawn, c_playerAny, "MedivhPortalRavenFamiliarCreateUnitPortalAsTarget");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Medivh - Raven Familiar Post Spawn Cloak
//--------------------------------------------------------------------------------------------------
bool libHMDV_gt_HeroMedivhRavenFamiliarPostSpawnCloak_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_raven;
    unit lv_player;
    int lv_targetPlayer;

    // Automatic Variable Declarations
    unitgroup autoB64B5ADC_g;
    int autoB64B5ADC_u;
    unit autoB64B5ADC_var;

    // Variable Initialization
    lv_player = EventUnit();
    lv_targetPlayer = UnitGetOwner(lv_player);

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

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

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

    autoB64B5ADC_g = UnitGroup("MedivhPortalRavenFamiliar", lv_targetPlayer, RegionPlayableMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    autoB64B5ADC_u = UnitGroupCount(autoB64B5ADC_g, c_unitCountAll);
    for (;; autoB64B5ADC_u -= 1) {
        autoB64B5ADC_var = UnitGroupUnitFromEnd(autoB64B5ADC_g, autoB64B5ADC_u);
        if (autoB64B5ADC_var == null) { break; }
        libHMDV_gf_HeroMedivhRavenFamiliartCloakController(lv_player, autoB64B5ADC_var);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHMDV_gt_HeroMedivhRavenFamiliarPostSpawnCloak_Init () {
    libHMDV_gt_HeroMedivhRavenFamiliarPostSpawnCloak = TriggerCreate("libHMDV_gt_HeroMedivhRavenFamiliarPostSpawnCloak_Func");
    TriggerEnable(libHMDV_gt_HeroMedivhRavenFamiliarPostSpawnCloak, false);
    TriggerAddEventUnitBehaviorChangeFromCategory(libHMDV_gt_HeroMedivhRavenFamiliarPostSpawnCloak, null, c_behaviorCategoryTemporaryCloak, c_unitBehaviorChangeAny);
    TriggerAddEventUnitBehaviorChangeFromCategory(libHMDV_gt_HeroMedivhRavenFamiliarPostSpawnCloak, null, c_behaviorCategoryPersistentCloak, c_unitBehaviorChangeAny);
    TriggerAddEventUnitBehaviorChangeFromCategory(libHMDV_gt_HeroMedivhRavenFamiliarPostSpawnCloak, null, c_behaviorCategoryUnrevealableCloak, c_unitBehaviorChangeAny);
}

//--------------------------------------------------------------------------------------------------
// Trigger: HeroAI - Medivh Has Landed
//--------------------------------------------------------------------------------------------------
bool libHMDV_gt_HeroAIMedivhHasLanded_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((libAIAI_gf_HeroAIIsAIEnabledForPlayer(UnitGetOwner(EventUnit())) == true))) {
            return false;
        }
    }

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

    AISetSuppressDangerPathing(EventUnit(), false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHMDV_gt_HeroAIMedivhHasLanded_Init () {
    libHMDV_gt_HeroAIMedivhHasLanded = TriggerCreate("libHMDV_gt_HeroAIMedivhHasLanded_Func");
    TriggerEnable(libHMDV_gt_HeroAIMedivhHasLanded, false);
    TriggerAddEventUnitAbility(libHMDV_gt_HeroAIMedivhHasLanded, null, AbilityCommand("MedivhTransformRavenLand", 0), c_unitAbilStageComplete, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: HeroAI - Medivh Has Cast Raven Form
//--------------------------------------------------------------------------------------------------
bool libHMDV_gt_HeroAIMedivhHasCastRavenForm_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((libAIAI_gf_HeroAIIsAIEnabledForPlayer(UnitGetOwner(EventUnit())) == true))) {
            return false;
        }
    }

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

    AISetSuppressDangerPathing(EventUnit(), true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHMDV_gt_HeroAIMedivhHasCastRavenForm_Init () {
    libHMDV_gt_HeroAIMedivhHasCastRavenForm = TriggerCreate("libHMDV_gt_HeroAIMedivhHasCastRavenForm_Func");
    TriggerEnable(libHMDV_gt_HeroAIMedivhHasCastRavenForm, false);
    TriggerAddEventUnitAbility(libHMDV_gt_HeroAIMedivhHasCastRavenForm, null, AbilityCommand("MedivhTransformRaven", 0), c_unitAbilStageComplete, false);
    TriggerAddEventUnitAbility(libHMDV_gt_HeroAIMedivhHasCastRavenForm, null, AbilityCommand("MedivhTransformRavenMorph", 0), c_unitAbilStageComplete, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: HeroAI - AI Medivh Register Portal Cast
//--------------------------------------------------------------------------------------------------
bool libHMDV_gt_HeroAIAIMedivhRegisterPortalCast_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_player;
    unitgroup lv_portals;
    unit lv_portalUnit;
    fixed lv_duration;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_portalUnit = EventUnit();
    lv_duration = 6.0;

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

    Wait(0.0625, c_timeGame);
    lv_player = UnitGetOwner(lv_portalUnit);
    if ((lv_player > libCore_gv_bALMaxPlayers)) {
        return true;
    }

    lv_portals = libHMDV_gf_HeroAIMedivhFindPortalPair(lv_player);
    if ((UnitGroupCount(lv_portals, c_unitCountAlive) != 2)) {
        return true;
    }

    if ((lv_portalUnit == UnitGroupUnit(lv_portals, 1))) {
        TriggerDebugOutput(1, StringToText(""), true);
        AIAddPortal(libGame_gf_ComputerPlayerInFaction(libGame_gv_players[lv_player].lv_faction), lv_portalUnit, UnitGroupUnit(lv_portals, 2), 0.5, lv_duration, "SmartCommandUnitInteraction", null);
    }
    else {
        TriggerDebugOutput(1, StringToText(""), true);
        AIAddPortal(libGame_gf_ComputerPlayerInFaction(libGame_gv_players[lv_player].lv_faction), lv_portalUnit, UnitGroupUnit(lv_portals, 1), 0.5, lv_duration, "SmartCommandUnitInteraction", null);
    }
    if (((libNtve_gf_UnitInRegion(lv_portalUnit, libMapM_gv_mMSafeRegions[libGame_gv_players[lv_player].lv_faction]) == true) && (libMapM_gv_mMSafeRegions[libGame_gv_players[lv_player].lv_faction] != null))) {
        UnitBehaviorAdd(lv_portalUnit, "MedivhPortalNotInHallOfStorms", lv_portalUnit, 1);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libHMDV_gt_HeroAIAIMedivhRegisterPortalCast_Init () {
    libHMDV_gt_HeroAIAIMedivhRegisterPortalCast = TriggerCreate("libHMDV_gt_HeroAIAIMedivhRegisterPortalCast_Func");
    TriggerEnable(libHMDV_gt_HeroAIAIMedivhRegisterPortalCast, false);
    TriggerAddEventUnitBehaviorChange(libHMDV_gt_HeroAIAIMedivhRegisterPortalCast, null, "MedivhPortalTimedLife", c_unitBehaviorChangeCreate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: HeroAI - AI Medivh Unregister Portal
//--------------------------------------------------------------------------------------------------
bool libHMDV_gt_HeroAIAIMedivhUnregisterPortal_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unitgroup lv_portals;
    unit lv_portalUnit;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_portals = libHMDV_gf_HeroAIMedivhFindPortalPair(UnitGetOwner(EventUnit()));
    lv_portalUnit = EventUnit();

    // Conditions
    if (testConds) {
        if (!((UnitGroupCount(lv_portals, c_unitCountAlive) == 2))) {
            return false;
        }
    }

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

    AIRemovePortal(lv_portalUnit);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHMDV_gt_HeroAIAIMedivhUnregisterPortal_Init () {
    libHMDV_gt_HeroAIAIMedivhUnregisterPortal = TriggerCreate("libHMDV_gt_HeroAIAIMedivhUnregisterPortal_Func");
    TriggerEnable(libHMDV_gt_HeroAIAIMedivhUnregisterPortal, false);
    TriggerAddEventUnitBehaviorChange(libHMDV_gt_HeroAIAIMedivhUnregisterPortal, null, "MedivhPortalAIUseLink", c_unitBehaviorChangeDecrease);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Medivh - Ley Line Seal Overlay On
//--------------------------------------------------------------------------------------------------
bool libHMDV_gt_HeroMedivhLeyLineSealOverlayOn_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_StasisOverlay.StormCutscene", EventUnitBehavior());
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libHMDV_gt_HeroMedivhLeyLineSealOverlayOn_Init () {
    libHMDV_gt_HeroMedivhLeyLineSealOverlayOn = TriggerCreate("libHMDV_gt_HeroMedivhLeyLineSealOverlayOn_Func");
    TriggerEnable(libHMDV_gt_HeroMedivhLeyLineSealOverlayOn, false);
    TriggerAddEventUnitBehaviorChange(libHMDV_gt_HeroMedivhLeyLineSealOverlayOn, null, "MedivhLeyLineSealStasis", c_unitBehaviorChangeActivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Medivh - Ley Line Seal Overlay Off
//--------------------------------------------------------------------------------------------------
bool libHMDV_gt_HeroMedivhLeyLineSealOverlayOff_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_StasisOverlay.StormCutscene", EventUnitBehavior());
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libHMDV_gt_HeroMedivhLeyLineSealOverlayOff_Init () {
    libHMDV_gt_HeroMedivhLeyLineSealOverlayOff = TriggerCreate("libHMDV_gt_HeroMedivhLeyLineSealOverlayOff_Func");
    TriggerEnable(libHMDV_gt_HeroMedivhLeyLineSealOverlayOff, false);
    TriggerAddEventUnitBehaviorChange(libHMDV_gt_HeroMedivhLeyLineSealOverlayOff, null, "MedivhLeyLineSealStasis", c_unitBehaviorChangeDestroy);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Medivh - Portal Camera Pan
//--------------------------------------------------------------------------------------------------
bool libHMDV_gt_HeroMedivhPortalCameraPan_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_teleportTarget;

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

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

    libGame_gf_CameraPanCameraForPlayerAndUpdateMapBoundsIfNecessary(UnitGetOwner(lv_teleportTarget), UnitGetPosition(lv_teleportTarget), 0.0, -1, 0.0, true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHMDV_gt_HeroMedivhPortalCameraPan_Init () {
    libHMDV_gt_HeroMedivhPortalCameraPan = TriggerCreate("libHMDV_gt_HeroMedivhPortalCameraPan_Func");
    TriggerEnable(libHMDV_gt_HeroMedivhPortalCameraPan, false);
    TriggerAddEventPlayerEffectUsed(libHMDV_gt_HeroMedivhPortalCameraPan, c_playerAny, "MedivhPortalTeleportToPortal");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Medivh - Portal Portal Mastery Selection (Clamping)
//--------------------------------------------------------------------------------------------------
bool libHMDV_gt_HeroMedivhPortalPortalMasterySelectionClamping_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_markerPortal;
    unit lv_portalCaster;

    // Automatic Variable Declarations
    // Variable Initialization

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

    lv_markerPortal = EventPlayerEffectUsedUnit(c_effectUnitTarget);
    lv_portalCaster = EventPlayerEffectUsedUnit(c_effectUnitCaster);
    UnitSelect(lv_markerPortal, UnitGetOwner(lv_portalCaster), true);
    UISetSelectionTypeEnabled(PlayerGroupSingle(UnitGetOwner(lv_portalCaster)), c_localSelectionTypeWorldPanelHero, false);
    while ((UnitIsAlive(lv_markerPortal) == true)) {
        Wait(0.125, c_timeGame);
    }
    UISetSelectionTypeEnabled(PlayerGroupSingle(UnitGetOwner(lv_portalCaster)), c_localSelectionTypeWorldPanelHero, true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHMDV_gt_HeroMedivhPortalPortalMasterySelectionClamping_Init () {
    libHMDV_gt_HeroMedivhPortalPortalMasterySelectionClamping = TriggerCreate("libHMDV_gt_HeroMedivhPortalPortalMasterySelectionClamping_Func");
    TriggerEnable(libHMDV_gt_HeroMedivhPortalPortalMasterySelectionClamping, false);
    TriggerAddEventPlayerEffectUsed(libHMDV_gt_HeroMedivhPortalPortalMasterySelectionClamping, c_playerAny, "MedivhPortalMarkerSpawnPersistent");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Medivh - Portal Portal Mastery Morph Back To Medivh
//--------------------------------------------------------------------------------------------------
bool libHMDV_gt_HeroMedivhPortalPortalMasteryMorphBackToMedivh_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_portal2Owner;
    unit lv_portal2Caster;
    unit lv_medivh;

    // Automatic Variable Declarations
    // Variable Initialization

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

    lv_portal2Caster = EventUnit();
    lv_portal2Owner = UnitGetOwner(lv_portal2Caster);
    lv_medivh = libGame_gv_players[lv_portal2Owner].lv_heroUnit;
    UnitCreateEffectUnit(lv_medivh, "MedivhAbilityPrepareSet", lv_medivh);
    UnitCreateEffectUnit(lv_medivh, "MedivhPortalCooldown", lv_medivh);
    UnitCreateEffectUnit(lv_medivh, "MedivhPortalCreateCasterDurationPersistent", lv_medivh);
    UnitBehaviorAdd(lv_medivh, "MedivhPortalPortalMasteryCastStun", lv_medivh, 1);
    libNtve_gf_MakeUnitFacePoint(lv_medivh, EventUnitTargetPoint(), 0.0625);
    if ((UnitOrderCount(lv_medivh) <= 1)) {
        UnitIssueOrder(lv_medivh, Order(AbilityCommand("stop", 0)), c_orderQueueReplace);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libHMDV_gt_HeroMedivhPortalPortalMasteryMorphBackToMedivh_Init () {
    libHMDV_gt_HeroMedivhPortalPortalMasteryMorphBackToMedivh = TriggerCreate("libHMDV_gt_HeroMedivhPortalPortalMasteryMorphBackToMedivh_Func");
    TriggerEnable(libHMDV_gt_HeroMedivhPortalPortalMasteryMorphBackToMedivh, false);
    TriggerAddEventUnitAbility(libHMDV_gt_HeroMedivhPortalPortalMasteryMorphBackToMedivh, null, AbilityCommand("MedivhPortal2", 0), c_abilEffectStageCast, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Medivh - Force of Will Behavior Responses
//--------------------------------------------------------------------------------------------------
bool libHMDV_gt_HeroMedivhForceofWillBehaviorResponses_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_medivhPlayer;
    fixed lv_damageTaken;
    unit lv_unit;
    fixed lv_verticalOffset;
    fixed lv_horizOffset;
    unit lv_caster;
    unit lv_shieldedUnit;
    int lv_ownerofShieldedUnit;
    fixed lv_healingModifier;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_damageTaken = EventUnitBehaviorCumulativeDamageModification();
    lv_unit = EventUnit();
    lv_verticalOffset = 2.0;
    lv_horizOffset = RandomFixed(-0.4, -0.6);
    lv_healingModifier = 0.2;

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

        if (!((UnitFilterMatch(lv_unit, UnitGetOwner(lv_unit), libCore_gv_filtersHeroic) == true))) {
            return false;
        }
    }

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

    if ((EventUnitBehaviorChange() == c_unitBehaviorChangeIncrease)) {
        lv_shieldedUnit = lv_unit;
        lv_ownerofShieldedUnit = UnitGetOwner(lv_shieldedUnit);
        lv_caster = UnitBehaviorEffectUnit(lv_shieldedUnit, EventUnitBehavior(), c_effectUnitCaster, 0);
        libHMDV_gv_medivhForceofWillCaster[UnitGetOwner(lv_shieldedUnit)] = lv_caster;
        libHMDV_gv_medivhForceofWillCasterOwner[UnitGetOwner(lv_shieldedUnit)] = UnitGetOwner(lv_caster);
        PlayerGroupAdd(libHMDV_gv_medivhForceofWillPlayerGroup[lv_ownerofShieldedUnit], lv_ownerofShieldedUnit);
        PlayerGroupAdd(libHMDV_gv_medivhForceofWillPlayerGroup[lv_ownerofShieldedUnit], UnitGetOwner(lv_caster));
    }
    else if ((EventUnitBehaviorChange() == c_unitBehaviorChangeDecrease)) {
        lv_shieldedUnit = lv_unit;
        lv_ownerofShieldedUnit = UnitGetOwner(lv_shieldedUnit);
        lv_medivhPlayer = libHMDV_gv_medivhForceofWillCasterOwner[UnitGetOwner(lv_shieldedUnit)];
        if ((lv_damageTaken > 0.0)) {
            CatalogFieldValueSetFixed(c_gameCatalogEffect, "MedivhForceOfWillModifyTalentTokenCount", "Value", lv_ownerofShieldedUnit, lv_damageTaken);
            UnitCreateEffectUnitWithSource(lv_shieldedUnit, "MedivhForceOfWillModifyTalentTokenCount", lv_shieldedUnit, c_gameCatalogAbil, "MedivhForceOfWill");
            lv_verticalOffset = 1.0;
            FloatingCombatElementCreateNumberTextAtUnit(libHMDV_gv_medivhForceofWillPlayerGroup[lv_ownerofShieldedUnit], "FloatingCombatElements/FloatingCombatAmountReadable", "", lv_shieldedUnit, FixedToInt(lv_damageTaken), StringExternal("Param/Value/lib_HMDV_C69061B6"), libNtve_gv_FloatingCombatTextAutoRandomSeed);
            if ((PlayerHasTalent(lv_medivhPlayer, "MedivhForceOfWillReabsorption") == true)) {
                CatalogFieldValueSetFixed(c_gameCatalogAccumulator, "MedivhForceOfWillHealingAccumulator", "Scale", lv_ownerofShieldedUnit, CatalogFieldValueGetAsFixed(c_gameCatalogAccumulator, "MedivhForceOfWillHealingDummyAccumulator", "Scale", lv_medivhPlayer));
            }
            else {
                CatalogFieldValueSetFixed(c_gameCatalogAccumulator, "MedivhForceOfWillHealingAccumulator", "Scale", lv_ownerofShieldedUnit, CatalogFieldValueGetAsFixed(c_gameCatalogAccumulator, "MedivhForceOfWillHealingDummyAccumulator", "Scale", 0));
            }
            UnitCreateEffectUnitWithSource(libHMDV_gv_medivhForceofWillCaster[lv_ownerofShieldedUnit], "MedivhForceOfWillReabsorptionHeal", lv_shieldedUnit, c_gameCatalogAbil, "MedivhForceOfWill");
            if ((PlayerHasTalent(lv_medivhPlayer, "MedivhForceOfWillEnduringWill") == true) && (lv_damageTaken >= CatalogFieldValueGetAsFixed(c_gameCatalogEffect, "MedivhForceOfWillEnduringWillTalentDummyTokenThreshold", "Value", lv_medivhPlayer))) {
                UnitCreateEffectUnitWithSource(libGame_gv_players[lv_medivhPlayer].lv_heroUnit, "MedivhForceOfWillEnduringWillTalentModifyCooldown", libGame_gv_players[lv_medivhPlayer].lv_heroUnit, c_gameCatalogAbil, "MedivhForceOfWill");
            }

            if ((PlayerHasTalent(lv_medivhPlayer, "MedivhForceofMagic") == true) && (lv_damageTaken >= CatalogFieldValueGetAsFixed(c_gameCatalogEffect, "MedivhForceOfWillForceofMagicTalentDummyTokenThreshold", "Value", lv_medivhPlayer))) {
                UnitCreateEffectUnitWithSource(libGame_gv_players[lv_medivhPlayer].lv_heroUnit, "MedivhForceOfWillApplyForceofMagicTalentStack", libGame_gv_players[lv_medivhPlayer].lv_heroUnit, c_gameCatalogAbil, "MedivhForceOfWill");
            }

        }
        else if ((lv_damageTaken > 0.0)) {
            FloatingCombatElementCreateNumberTextAtUnit(libHMDV_gv_medivhForceofWillPlayerGroup[lv_ownerofShieldedUnit], "FloatingCombatElements/FloatingCombatAmountReadable", "", lv_shieldedUnit, FixedToInt(lv_damageTaken), StringExternal("Param/Value/lib_HMDV_EB9E6C70"), libNtve_gv_FloatingCombatTextAutoRandomSeed);
        }
        if ((PlayerHasTalent(lv_medivhPlayer, "MedivhForceOfWillArcaneExplosion") == true)) {
            CatalogFieldValueSetFixed(c_gameCatalogAccumulator, "MedivhArcaneExplosionDamageAccumulator", "MaxAccumulation", lv_ownerofShieldedUnit, CatalogFieldValueGetAsFixed(c_gameCatalogAccumulator, "MedivhArcaneExplosionDamageAccumulator", "MaxAccumulation", lv_medivhPlayer));
            CatalogFieldValueSetFixed(c_gameCatalogEffect, "MedivhForceOfWillArcaneExplosionDamage", "Amount", lv_ownerofShieldedUnit, CatalogFieldValueGetAsFixed(c_gameCatalogEffect, "MedivhForceOfWillArcaneExplosionDamage", "Amount", lv_medivhPlayer));
            UnitCreateEffectUnitWithSource(libGame_gv_players[lv_medivhPlayer].lv_heroUnit, "MedivhForceOfWillArcaneExplosionSearch", lv_shieldedUnit, c_gameCatalogAbil, "MedivhForceOfWill");
        }

        PlayerGroupClear(libHMDV_gv_medivhForceofWillPlayerGroup[lv_ownerofShieldedUnit]);
        Wait(0.0625, c_timeGame);
        UnitCreateEffectUnit(lv_shieldedUnit, "MedivhForceOfWillResetTalentTokenCount", lv_shieldedUnit);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHMDV_gt_HeroMedivhForceofWillBehaviorResponses_Init () {
    libHMDV_gt_HeroMedivhForceofWillBehaviorResponses = TriggerCreate("libHMDV_gt_HeroMedivhForceofWillBehaviorResponses_Func");
    TriggerEnable(libHMDV_gt_HeroMedivhForceofWillBehaviorResponses, false);
    TriggerAddEventUnitBehaviorChange(libHMDV_gt_HeroMedivhForceofWillBehaviorResponses, null, "MedivhForceOfWill", c_unitBehaviorChangeIncrease);
    TriggerAddEventUnitBehaviorChange(libHMDV_gt_HeroMedivhForceofWillBehaviorResponses, null, "MedivhForceOfWill", c_unitBehaviorChangeDecrease);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Medivh - Force of Will - Remove Early
//--------------------------------------------------------------------------------------------------
bool libHMDV_gt_HeroMedivhForceofWillRemoveEarly_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    while ((UnitBehaviorDuration(EventUnit(), "MedivhForceOfWill") > 0.0625)) {
        Wait(0.0625, c_timeGame);
    }
    UnitBehaviorRemove(EventUnit(), EventUnitBehavior(), 1);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHMDV_gt_HeroMedivhForceofWillRemoveEarly_Init () {
    libHMDV_gt_HeroMedivhForceofWillRemoveEarly = TriggerCreate("libHMDV_gt_HeroMedivhForceofWillRemoveEarly_Func");
    TriggerEnable(libHMDV_gt_HeroMedivhForceofWillRemoveEarly, false);
    TriggerAddEventUnitBehaviorChange(libHMDV_gt_HeroMedivhForceofWillRemoveEarly, null, "MedivhForceOfWill", c_unitBehaviorChangeCreate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Medivh - Transform: Raven After Port To Town
//--------------------------------------------------------------------------------------------------
bool libHMDV_gt_HeroMedivhTransformRavenAfterPortToTown_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_player;
    unit lv_medivhUnit;

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

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

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

    lv_medivhUnit = libGame_gv_players[lv_player].lv_heroUnit;
    UnitCreateEffectUnit(lv_medivhUnit, "MedivhTransformRavenFountainSet", lv_medivhUnit);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHMDV_gt_HeroMedivhTransformRavenAfterPortToTown_Init () {
    libHMDV_gt_HeroMedivhTransformRavenAfterPortToTown = TriggerCreate("libHMDV_gt_HeroMedivhTransformRavenAfterPortToTown_Func");
    TriggerEnable(libHMDV_gt_HeroMedivhTransformRavenAfterPortToTown, false);
    libGame_gf_HeroPortedBackToTown(libHMDV_gt_HeroMedivhTransformRavenAfterPortToTown);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Medivh - Transform: Raven Mounting Special Case
//--------------------------------------------------------------------------------------------------
bool libHMDV_gt_HeroMedivhTransformRavenMountingSpecialCase_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_player;

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

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

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

    UnitCreateEffectUnit(libGame_gv_players[lv_player].lv_heroUnit, "MedivhTransformRavenFountainSet", libGame_gv_players[lv_player].lv_heroUnit);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHMDV_gt_HeroMedivhTransformRavenMountingSpecialCase_Init () {
    libHMDV_gt_HeroMedivhTransformRavenMountingSpecialCase = TriggerCreate("libHMDV_gt_HeroMedivhTransformRavenMountingSpecialCase_Func");
    TriggerEnable(libHMDV_gt_HeroMedivhTransformRavenMountingSpecialCase, false);
    libGame_gf_HeroSpecialCaseMounting(libHMDV_gt_HeroMedivhTransformRavenMountingSpecialCase);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Medivh - Transform: Swap To Medivh
//--------------------------------------------------------------------------------------------------
bool libHMDV_gt_HeroMedivhTransformSwapToMedivh_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_player;
    int lv_index;

    // Automatic Variable Declarations
    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((UnitGetOwner(EventUnit()) >= 1))) {
            return false;
        }

        if (!((UnitGetOwner(EventUnit()) <= 10))) {
            return false;
        }

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

        if (!((UnitIsAlive(EventUnit()) == true))) {
            return false;
        }

        if (!((UnitBehaviorCount(EventUnit(), "MedivhForceOfWill") > 0))) {
            return false;
        }
    }

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

    lv_player = UnitGetOwner(EventUnit());
    lv_index = libUIUI_gf_UIUnitStatusFramesGetUnitIndex(lv_player, EventUnit());
    Wait(0.0625, c_timeGame);
    DialogControlSendAnimationEvent(libUIUI_gv_uIHeroStatusFrames[lv_player].lv_unitHealthBarInvincible[lv_index], PlayerGroupAll(), "InvincibleOn");
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHMDV_gt_HeroMedivhTransformSwapToMedivh_Init () {
    libHMDV_gt_HeroMedivhTransformSwapToMedivh = TriggerCreate("libHMDV_gt_HeroMedivhTransformSwapToMedivh_Func");
    TriggerEnable(libHMDV_gt_HeroMedivhTransformSwapToMedivh, false);
    TriggerAddEventUnitBehaviorChange(libHMDV_gt_HeroMedivhTransformSwapToMedivh, null, "MedivhTransformRaven", c_unitBehaviorChangeDestroy);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Medivh - Portal Mastery CDR
//--------------------------------------------------------------------------------------------------
bool libHMDV_gt_HeroMedivhPortalMasteryCDR_Func (bool testConds, bool runActions) {
    // Variable Declarations
    string lv_triggeringEffect;
    unit lv_target;
    int lv_player;

    // Automatic Variable Declarations
    string auto3CF91448_val;

    // Variable Initialization
    lv_triggeringEffect = EventPlayerEffectUsed();
    lv_target = EventPlayerEffectUsedUnit(c_effectUnitTarget);
    lv_player = EventPlayerEffectUsedUnitOwner(c_effectPlayerTarget);

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

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

        if (!(((UnitGetType(lv_target) == "HeroMedivh") || (UnitGetType(lv_target) == "HeroMedivhRaven")))) {
            return false;
        }
    }

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

    auto3CF91448_val = lv_triggeringEffect;
    if (auto3CF91448_val == "MalfurionInnervateModifyUnitDummy") {
        UnitCreateEffectUnit(lv_target, "MedivhPortalMasteryInnervateModifyPlayer", lv_target);
    }
    else if (auto3CF91448_val == "AnaNanoBoostPeriodicDummyModifyUnit") {
        UnitCreateEffectUnit(lv_target, "MedivhPortalMasteryNanoBoostModifyPlayer", lv_target);
    }
    else {
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHMDV_gt_HeroMedivhPortalMasteryCDR_Init () {
    libHMDV_gt_HeroMedivhPortalMasteryCDR = TriggerCreate("libHMDV_gt_HeroMedivhPortalMasteryCDR_Func");
    TriggerEnable(libHMDV_gt_HeroMedivhPortalMasteryCDR, false);
    TriggerAddEventPlayerEffectUsed(libHMDV_gt_HeroMedivhPortalMasteryCDR, c_playerAny, "MalfurionInnervateModifyUnitDummy");
    TriggerAddEventPlayerEffectUsed(libHMDV_gt_HeroMedivhPortalMasteryCDR, c_playerAny, "AnaNanoBoostPeriodicDummyModifyUnit");
}

void libHMDV_InitTriggers () {
    libHMDV_gt_HeroMedivhRavenFamiliarSpawn_Init();
    libHMDV_gt_HeroMedivhRavenFamiliarPostSpawnCloak_Init();
    libHMDV_gt_HeroAIMedivhHasLanded_Init();
    libHMDV_gt_HeroAIMedivhHasCastRavenForm_Init();
    libHMDV_gt_HeroAIAIMedivhRegisterPortalCast_Init();
    libHMDV_gt_HeroAIAIMedivhUnregisterPortal_Init();
    libHMDV_gt_HeroMedivhLeyLineSealOverlayOn_Init();
    libHMDV_gt_HeroMedivhLeyLineSealOverlayOff_Init();
    libHMDV_gt_HeroMedivhPortalCameraPan_Init();
    libHMDV_gt_HeroMedivhPortalPortalMasterySelectionClamping_Init();
    libHMDV_gt_HeroMedivhPortalPortalMasteryMorphBackToMedivh_Init();
    libHMDV_gt_HeroMedivhForceofWillBehaviorResponses_Init();
    libHMDV_gt_HeroMedivhForceofWillRemoveEarly_Init();
    libHMDV_gt_HeroMedivhTransformRavenAfterPortToTown_Init();
    libHMDV_gt_HeroMedivhTransformRavenMountingSpecialCase_Init();
    libHMDV_gt_HeroMedivhTransformSwapToMedivh_Init();
    libHMDV_gt_HeroMedivhPortalMasteryCDR_Init();
}

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

void libHMDV_InitLib () {
    if (libHMDV_InitLib_completed) {
        return;
    }

    libHMDV_InitLib_completed = true;

    libHMDV_InitLibraries();
    libHMDV_InitVariables();
    libHMDV_InitTriggers();
}