include "TriggerLibs/NativeLib"

include "TriggerLibs/HeroesLib"

include "TriggerLibs/GameLib"

include "TriggerLibs/AILib"

include "TriggerLibs/UILib"

include "TriggerLibs/SoundLib"

include "TriggerLibs/GameDataHelperLib"



include "LibHDVA_h"



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

// Library: DVa

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

// External Library Initialization

void libHDVA_InitLibraries () {

    libNtve_InitVariables();

    libCore_InitVariables();

    libGame_InitVariables();

    libAIAI_InitVariables();

    libUIUI_InitVariables();

    libSond_InitVariables();

    libGDHL_InitVariables();

}



// Variable Initialization

bool libHDVA_InitVariables_completed = false;



void libHDVA_InitVariables () {

    if (libHDVA_InitVariables_completed) {

        return;

    }



    libHDVA_InitVariables_completed = true;



    libHDVA_gv_dVaUI.lv_partyFrame = c_invalidDialogControlId;

    libHDVA_gv_dVaUI.lv_mainPanel = c_invalidDialogControlId;

    libHDVA_gv_dVaUI.lv_defenseMatrixLabel = c_invalidDialogControlId;

    libHDVA_gv_dVaUI.lv_defenseMatrixOffAnimation = c_invalidDialogControlId;

    libHDVA_gv_dVaCallMechFullMetalHealthModifier = (CatalogFieldValueGetAsFixed(c_gameCatalogBehavior, "DVaFullMetalCarry", "Modification.VitalMaxFractionArray[" + IntToString(0) + "]", c_playerAny) + 1.0);

    libHDVA_gv_dVaCallMechSummonedMechTargetPointOffset_C = 1.5;

}



// Functions

void libHDVA_gf_HeroDVaIncrementHeroCountFunction () {

    // Automatic Variable Declarations

    // Implementation

    libHDVA_gv_heroDVaTriggerRegistrationCount += 1;

    if ((libHDVA_gv_heroDVaTriggerRegistrationCount == 1)) {

        TriggerEnable(libHDVA_gt_HeroDVaActorSoundSwaps, true);

        TriggerEnable(libHDVA_gt_DVaCallMech, true);

        TriggerEnable(libHDVA_gt_DVaCallMechMEKAfallCompleted, true);

        TriggerEnable(libHDVA_gt_DVaCallMechInterrupted, true);

        TriggerEnable(libHDVA_gt_DVaCargoUnloadedSelectionControl, true);

        TriggerEnable(libHDVA_gt_HeroDVaHeroWeaponTargeting, true);

        TriggerEnable(libHDVA_gt_HeroDVaTargetAcquired, true);

        TriggerEnable(libHDVA_gt_HeroDVaHoldFireControllerHoldFireApply, true);

        TriggerEnable(libHDVA_gt_HeroDVaHoldFireControllerHoldFireRemove, true);

        TriggerEnable(libHDVA_gt_DVaTalentBehaviorAcquiredWhileCargoForwarding, true);

        TriggerEnable(libHDVA_gt_DVaMoonwellRedistribution, true);

        TriggerEnable(libHDVA_gt_DVaDamageTakenSelfDestructCharge, true);

        TriggerEnable(libHDVA_gt_HeroDVaMechDiesviaFatalDamage, true);

        TriggerEnable(libHDVA_gt_DVaAbathurCreatesaDVaClone, true);

        TriggerEnable(libHDVA_gt_DVaAbathurClonedMechEnds, true);

        TriggerEnable(libHDVA_gt_HeroDVaPilotEjectedMoveCommandForwarding, true);

        TriggerEnable(libHDVA_gt_HeroDVaRemoveweapontargetfromData, true);

        TriggerEnable(libHDVA_gt_DVaLiquidCoolingDurationFix, true);

        TriggerEnable(libHDVA_gt_DVaPilotUpdateEnergyTriggerconditions, true);

        TriggerEnable(libHDVA_gt_DVaPilotUpdateEnergyMechSelfDestructing, true);

        TriggerEnable(libHDVA_gt_DVaDefenseMatrixTracker, true);

        TriggerEnable(libHDVA_gt_DVaDefenseMatrixTrackerReportandReset, true);

        TriggerEnable(libHDVA_gt_HeroDVaHeroWeaponForceAcquireTargetTaunt, true);

        TriggerEnable(libHDVA_gt_DVaBoostersEnemyHallofStorms, true);

        TriggerEnable(libHDVA_gt_DVaAblativeArmorHealingConversion, true);

        TriggerEnable(libHDVA_gt_HeroDVaMicroMissilesActive, true);

        TriggerEnable(libHDVA_gt_HeroDVaFusionGeneratorFCTFinal, true);

        TriggerEnable(libHDVA_gt_HeroDVaFusionGeneratorFCTIncrement, true);

    }



}



void libHDVA_gf_HeroDVaDecrementHeroCountFunction () {

    // Automatic Variable Declarations

    // Implementation

    libHDVA_gv_heroDVaTriggerRegistrationCount -= 1;

    if ((libHDVA_gv_heroDVaTriggerRegistrationCount < 0)) {

        libHDVA_gv_heroDVaTriggerRegistrationCount = 0;

    }



    if ((libHDVA_gv_heroDVaTriggerRegistrationCount == 0)) {

        TriggerEnable(libHDVA_gt_HeroDVaActorSoundSwaps, false);

        TriggerEnable(libHDVA_gt_DVaCallMech, false);

        TriggerEnable(libHDVA_gt_DVaCallMechInterrupted, false);

        TriggerEnable(libHDVA_gt_DVaCallMechMEKAfallCompleted, false);

        TriggerEnable(libHDVA_gt_DVaCargoUnloadedSelectionControl, false);

        TriggerEnable(libHDVA_gt_HeroDVaHeroWeaponTargeting, false);

        TriggerEnable(libHDVA_gt_HeroDVaTargetAcquired, false);

        TriggerEnable(libHDVA_gt_HeroDVaHoldFireControllerHoldFireApply, false);

        TriggerEnable(libHDVA_gt_HeroDVaHoldFireControllerHoldFireRemove, false);

        TriggerEnable(libHDVA_gt_DVaTalentBehaviorAcquiredWhileCargoForwarding, false);

        TriggerEnable(libHDVA_gt_DVaMoonwellRedistribution, false);

        TriggerEnable(libHDVA_gt_DVaDamageTakenSelfDestructCharge, false);

        TriggerEnable(libHDVA_gt_HeroDVaMechDiesviaFatalDamage, false);

        TriggerEnable(libHDVA_gt_DVaAbathurCreatesaDVaClone, false);

        TriggerEnable(libHDVA_gt_DVaAbathurClonedMechEnds, false);

        TriggerEnable(libHDVA_gt_HeroDVaPilotEjectedMoveCommandForwarding, false);

        TriggerEnable(libHDVA_gt_HeroDVaRemoveweapontargetfromData, false);

        TriggerEnable(libHDVA_gt_DVaLiquidCoolingDurationFix, false);

        TriggerEnable(libHDVA_gt_DVaPilotUpdateEnergyTriggerconditions, false);

        TriggerEnable(libHDVA_gt_DVaPilotUpdateEnergyMechSelfDestructing, false);

        TriggerEnable(libHDVA_gt_DVaDefenseMatrixTracker, false);

        TriggerEnable(libHDVA_gt_DVaDefenseMatrixTrackerReportandReset, false);

        TriggerEnable(libHDVA_gt_HeroDVaHeroWeaponForceAcquireTargetTaunt, false);

        TriggerEnable(libHDVA_gt_DVaBoostersEnemyHallofStorms, false);

        TriggerEnable(libHDVA_gt_DVaAblativeArmorHealingConversion, false);

        TriggerEnable(libHDVA_gt_HeroDVaMicroMissilesActive, false);

        TriggerEnable(libHDVA_gt_HeroDVaFusionGeneratorFCTFinal, false);

        TriggerEnable(libHDVA_gt_HeroDVaFusionGeneratorFCTIncrement, false);

    }



}



void libHDVA_gf_HeroDVaUIInitialize () {

    int init_i;



    // Variable Declarations

    int[6] lv_panel;

    int lv_currentPanelLayer;



    // Automatic Variable Declarations

    // Variable Initialization

    for (init_i = 0; init_i <= 5; init_i += 1) {

        lv_panel[init_i] = c_invalidDialogControlId;

    }



    // Implementation

    DialogControlHookup(libUIUI_gv_heroSpecificStatusContainer, c_triggerControlTypePanel, "DVaMechDefenceMatrixFrame");

    libHDVA_gv_dVaUI.lv_mainPanel = DialogControlLastCreated();

    lv_currentPanelLayer += 1;

    lv_panel[lv_currentPanelLayer] = DialogControlLastCreated();

    DialogControlHookup(lv_panel[lv_currentPanelLayer], c_triggerControlTypeLabel, "UnitStatusFrame0/DefenseMatrixAbsorbedValueLabel");

    libHDVA_gv_dVaUI.lv_defenseMatrixLabel = DialogControlLastCreated();

    DialogControlHookup(lv_panel[lv_currentPanelLayer], c_triggerControlTypePanel, "UnitStatusFrame0/DefenseMatrixAnims2");

    libHDVA_gv_dVaUI.lv_defenseMatrixOffAnimation = DialogControlLastCreated();

    DialogControlHookupStandard(c_triggerControlTypePanel, "UIContainer/ConsoleUIContainer/PartyFramePanel");

    libHDVA_gv_dVaUI.lv_partyFrame = DialogControlLastCreated();

}



trigger auto_libHDVA_gf_SpawnDVa_Trigger = null;

int auto_libHDVA_gf_SpawnDVa_lp_player;

int auto_libHDVA_gf_SpawnDVa_lp_heroIndex;

point auto_libHDVA_gf_SpawnDVa_lp_spawnLocation;



void libHDVA_gf_SpawnDVa (int lp_player, int lp_heroIndex, point lp_spawnLocation) {

    auto_libHDVA_gf_SpawnDVa_lp_player = lp_player;

    auto_libHDVA_gf_SpawnDVa_lp_heroIndex = lp_heroIndex;

    auto_libHDVA_gf_SpawnDVa_lp_spawnLocation = lp_spawnLocation;



    if (auto_libHDVA_gf_SpawnDVa_Trigger == null) {

        auto_libHDVA_gf_SpawnDVa_Trigger = TriggerCreate("auto_libHDVA_gf_SpawnDVa_TriggerFunc");

    }



    TriggerExecute(auto_libHDVA_gf_SpawnDVa_Trigger, false, false);

}



bool auto_libHDVA_gf_SpawnDVa_TriggerFunc (bool testConds, bool runActions) {

    int lp_player = auto_libHDVA_gf_SpawnDVa_lp_player;

    int lp_heroIndex = auto_libHDVA_gf_SpawnDVa_lp_heroIndex;

    point lp_spawnLocation = auto_libHDVA_gf_SpawnDVa_lp_spawnLocation;



    // Variable Declarations

    int lv_playerPartyFrameDialog;

    int lv_teamPartyFrameDialog;

    int lv_owningFaction;

    int lv_playerRoster;

    unit lv_dVaMechUnit;

    unit lv_dVaPilotUnit;

    int lv_skinIndex;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_playerPartyFrameDialog = c_invalidDialogControlId;

    lv_teamPartyFrameDialog = c_invalidDialogControlId;



    // Implementation

    if ((libGame_gv_players[lp_player].lv_heroUnit != null)) {

        return true;

    }



    while (!((libGame_gv_players[lp_player].lv_heroSpawnReady == true))) {

        Wait(0.0625, c_timeGame);

    }

    lv_skinIndex = lp_player;

    if ((libGame_gv_players[lv_skinIndex].lv_skinData.lv_skinID != null)) {

        PlayerSetSkin(lp_player, libGame_gv_players[lv_skinIndex].lv_skinData.lv_skinID);

    }



    libNtve_gf_CreateUnitsAtPoint2(1, "HeroDVaMech", c_unitCreateIgnorePlacement, lp_player, lp_spawnLocation, null);

    lv_dVaMechUnit = UnitLastCreated();

    UnitCargoCreate(UnitLastCreated(), "HeroDVaPilot", 1);

    lv_dVaPilotUnit = UnitCargoLastCreated();

    libGame_gv_players[lp_player].lv_heroUnit = lv_dVaPilotUnit;

    libAIAI_gv_aIHeroes[lp_player].lv_currentHeroUnit = lv_dVaMechUnit;

    PlayerAddChargeUsed(lp_player, "Abil/DVaMechSelfDestruct", (CatalogFieldValueGetAsFixed(c_gameCatalogAbil, "DVaMechSelfDestruct", "Cost.Charge.CountMax", lp_player) - PlayerGetChargeUsed(lp_player, "Abil/DVaMechSelfDestruct")));

    UnitGroupClear(libGame_gv_players[lp_player].lv_heroUnitGroup);

    UnitGroupAdd(libGame_gv_players[lp_player].lv_heroUnitGroup, lv_dVaMechUnit);

    UnitGroupAdd(libGame_gv_players[lp_player].lv_heroUnitGroup, lv_dVaPilotUnit);

    AIAddPlayerUnit(libGame_gv_players[lp_player].lv_heroUnit);

    libGame_gv_players[lp_player].lv_heroIndex = lp_player;

    libGame_gv_players[lp_player].lv_portraitIcon = libGame_gv_players[lp_player].lv_heroData.lv_portrait;

    libGame_gv_players[lp_player].lv_vOSoundSuffix = "";

    libCore_gf_DataHeroVOReloadHeroVODataForHero(lp_player);

    libCore_gf_SendPlayersSkinActorMessagesToUnit(lp_player, lv_dVaPilotUnit);

    libCore_gf_SendPlayersSkinActorMessagesToUnit(lp_player, lv_dVaMechUnit);

    UnitGroupAdd(libGame_gv_heroes, lv_dVaPilotUnit);

    UnitStatusBarOverride(lv_dVaPilotUnit, c_unitStatusGroupAll);

    libUIUI_gf_InitPathingLines(lv_dVaMechUnit, lp_player);

    libUIUI_gf_InitPathingLines(lv_dVaPilotUnit, lp_player);

    if ((libGame_gv_suppressInitialHeroSpawnFX == false)) {

        libNtve_gf_SendActorMessageToUnit(lv_dVaMechUnit, "Signal Respawn");

    }



    PlayerSetHeroUnit(lp_player, lv_dVaMechUnit);

    UnitSelect(lv_dVaMechUnit, lp_player, true);

    libGame_gv_players[lp_player].lv_playerStatus = libGame_ge_PlayerStatusStorm_Playing;

    libGame_gv_players[lp_player].lv_isDead = false;

    libUIUI_gf_HeroConsoleUnitStatusBarsSetUnitForBars(lv_dVaMechUnit, lp_player);

    libUIUI_gf_UIHeroConsoleSetUpForPlayer(lv_dVaMechUnit, lp_player);

    libUIUI_gf_UIUnitStatusFramesHookupUnitStatusFramesForPlayer(lp_player);

    libUIUI_gf_UIHeroConsoleShowHideForPlayer(true, lp_player);

    libUIUI_gf_UIPartyFrameAddPlayerToPartyFrame(lp_player);

    if ((libNtve_gf_PlayerInCinematicMode(lp_player) == false)) {

        UISetMode(libCore_gv_playerGroupFromPlayer[lp_player], c_uiModeConsole, c_transitionDurationImmediate);

        libUIUI_gf_UIPartyFrameShowHidePartyFramePanelForPlayer(true, lp_player);

        libUIUI_gf_UIGameUIShowHideConsolePanelForPlayer(true, lp_player);

    }



    PlayerSetHero(lp_player, libGame_gv_players[lp_player].lv_heroData.lv_heroCatalogLink);

    StatEventCreate("PlayerSpawned");

    StatEventAddDataInt(StatEventLastCreated(), "PlayerID", lp_player);

    StatEventAddDataString(StatEventLastCreated(), "Hero", (libGame_gv_players[lp_player].lv_heroData.lv_unitType));

    StatEventSend(StatEventLastCreated());

    ActorScopeSend(ActorScopeFromUnit(libGame_gv_players[lp_player].lv_heroUnit), "StatusIncrement PreventDestroyOnDeath");

    libGame_gv_players[lp_player].lv_cameraPlayerUnitGroupToFocusOn = libNtve_gf_ConvertUnitToUnitGroup(lv_dVaMechUnit);

    if (((lp_player != 1) || (libCore_gv_sYSGameMode != libCore_ge_GameModes_Tutorial1) || (libNtve_gf_PlayerInCinematicMode(1) == false))) {

        libGame_gf_CameraUpdateCameraForPlayer(lp_player);

    }



    Wait(0.125, c_timeGame);

    libGame_gf_GrantXPToPlayer(libCore_gf_GetTotalXPForLevel(libCore_gv_sYSHeroStartLevel), lp_player, libGame_ge_XPSources_Trickle);

    libCore_gf_SetTalentsTierLevels(lp_player);

    libCore_gf_SetHeroicTalentTier(lp_player);

    libGame_gf_TalentsSetupTalentChoicesFromHeroDataForPlayer(lp_heroIndex, lp_player);

    if ((libCore_gv_tUTTalentsAutobuyOn == true)) {

        libGame_gf_SendEventHeroGainTalent("", lp_player);

    }



    SetTalentTreeHeroLevel(lp_player, 0);

    libGame_gf_LevelUpHero(libGame_gv_players[lp_player].lv_heroUnit);

    libUIUI_gf_UIObserverUIAddPlayerToObserverUI(lp_player);

    libSond_gv_soundtrack_UniqueSoundtrackEnabled[lp_player] = false;

    libGame_gf_SendEventHeroSpawn(lp_player);

    CatalogFieldValueSet(c_gameCatalogAbil, "Mount", "CastIntroTime[" + IntToString(0) + "]", lp_player, CatalogFieldValueGet(c_gameCatalogAbil, "Mount", "CastIntroTime[" + IntToString(0) + "]", 0));

    CatalogFieldValueSet(c_gameCatalogAbil, "Mount", "Cost[" + IntToString(0) + "].Cooldown.TimeUse", lp_player, CatalogFieldValueGet(c_gameCatalogAbil, "Mount", "Cost.Cooldown.TimeUse", 0));

    libHDVA_gf_DVaUpdatethePartyFrametoActiveUnit(lp_player);

    AIRemovePlayerUnit(lv_dVaPilotUnit);

    AIAddPlayerUnit(lv_dVaMechUnit);

    libUIUI_gv_uIHeroStatusFrames[lp_player].lv_unitCount = 0;

    libUIUI_gf_UIUnitStatusFramesUpdateUnitStatusFramesForUnit(lp_player, lv_dVaMechUnit);

    libAIAI_gf_AITeamDelegateModifyHeroStatusTokensforTeam(libAIAI_ge_AITeamDelegateAddRemoveLaneValue_Add, libGame_gv_players[lp_player].lv_aIHeroDelegateTokenValue, libGame_gf_TeamNumberOfPlayer(lp_player), libAIAI_ge_AITeamDelegateLivingDeadHeroStatusUpdates_HeroAlive);

    return true;

}



trigger auto_libHDVA_gf_RespawnHeroDVa_Trigger = null;

unit auto_libHDVA_gf_RespawnHeroDVa_lp_pilotUnit;

int auto_libHDVA_gf_RespawnHeroDVa_lp_player;

point auto_libHDVA_gf_RespawnHeroDVa_lp_spawnLocation;

int auto_libHDVA_gf_RespawnHeroDVa_lp_respawnedMechHealthPercentage;



void libHDVA_gf_RespawnHeroDVa (unit lp_pilotUnit, int lp_player, point lp_spawnLocation, int lp_respawnedMechHealthPercentage) {

    auto_libHDVA_gf_RespawnHeroDVa_lp_pilotUnit = lp_pilotUnit;

    auto_libHDVA_gf_RespawnHeroDVa_lp_player = lp_player;

    auto_libHDVA_gf_RespawnHeroDVa_lp_spawnLocation = lp_spawnLocation;

    auto_libHDVA_gf_RespawnHeroDVa_lp_respawnedMechHealthPercentage = lp_respawnedMechHealthPercentage;



    if (auto_libHDVA_gf_RespawnHeroDVa_Trigger == null) {

        auto_libHDVA_gf_RespawnHeroDVa_Trigger = TriggerCreate("auto_libHDVA_gf_RespawnHeroDVa_TriggerFunc");

    }



    TriggerExecute(auto_libHDVA_gf_RespawnHeroDVa_Trigger, false, false);

}



bool auto_libHDVA_gf_RespawnHeroDVa_TriggerFunc (bool testConds, bool runActions) {

    unit lp_pilotUnit = auto_libHDVA_gf_RespawnHeroDVa_lp_pilotUnit;

    int lp_player = auto_libHDVA_gf_RespawnHeroDVa_lp_player;

    point lp_spawnLocation = auto_libHDVA_gf_RespawnHeroDVa_lp_spawnLocation;

    int lp_respawnedMechHealthPercentage = auto_libHDVA_gf_RespawnHeroDVa_lp_respawnedMechHealthPercentage;



    // Variable Declarations

    unit lv_dVaMechUnit;

    unit lv_dVaPilotUnit;

    int lv_skinIndex;



    // Automatic Variable Declarations

    // Variable Initialization



    // Implementation

    libNtve_gf_CreateUnitsAtPoint2(1, "HeroDVaMech", c_unitCreateIgnorePlacement, lp_player, lp_spawnLocation, null);

    lv_dVaMechUnit = UnitLastCreated();

    lv_dVaPilotUnit = lp_pilotUnit;

    libNtve_gf_ShowHideUnit(lv_dVaPilotUnit, false);

    UnitKill(libGame_gv_players[lp_player].lv_gravestone);

    UnitBehaviorRemove(lv_dVaPilotUnit, "Dead", 1);

    UnitBehaviorRemove(lv_dVaPilotUnit, "DeadMechanics", 1);

    UnitBehaviorRemove(lv_dVaMechUnit, "HeroGenericMapMechanicPickupDisallowed", 1);

    UnitRevive(lv_dVaPilotUnit);

    libNtve_gf_ShowHideUnit(lv_dVaPilotUnit, true);

    UnitPutInTransport(lv_dVaPilotUnit, lv_dVaMechUnit);

    libNtve_gf_MakeUnitUncommandable(lv_dVaMechUnit, true);

    UnitSetState(lv_dVaPilotUnit, c_unitStateStatusBar, true);

    libAIAI_gv_aIHeroes[lp_player].lv_currentHeroUnit = lv_dVaMechUnit;

    UnitGroupClear(libGame_gv_players[lp_player].lv_heroUnitGroup);

    UnitGroupAdd(libGame_gv_players[lp_player].lv_heroUnitGroup, lv_dVaMechUnit);

    UnitGroupAdd(libGame_gv_players[lp_player].lv_heroUnitGroup, lv_dVaPilotUnit);

    libCore_gf_SendPlayersSkinActorMessagesToUnit(lp_player, lv_dVaMechUnit);

    UnitStatusBarOverride(lv_dVaPilotUnit, c_unitStatusGroupAll);

    PlayerSetHeroUnit(lp_player, lv_dVaMechUnit);

    UnitSelect(lv_dVaMechUnit, lp_player, true);

    libUIUI_gf_InitPathingLines(lv_dVaMechUnit, lp_player);

    libGame_gv_players[lp_player].lv_isDead = false;

    libUIUI_gf_HeroConsoleUnitStatusBarsSetUnitForBars(lv_dVaMechUnit, lp_player);

    libUIUI_gf_UIHeroConsoleSetUpForPlayer(lv_dVaMechUnit, lp_player);

    libUIUI_gf_UIUnitStatusFramesHookupUnitStatusFramesForPlayer(lp_player);

    libGame_gf_SendEventHeroRespawn(lp_player, lv_dVaPilotUnit);

    libUIUI_gf_FullscreenOverlaysShowHideDeathOverlay(false, lp_player);

    UIAlert("YourHeroHasRevived", lp_player, StringToText(""), null);

    libGame_gf_AfkResumeWarningTimerForPlayer(lp_player);

    libNtve_gf_SendActorMessageToUnit(lv_dVaMechUnit, "Signal Respawn");

    libGame_gf_HeroDeathEnableDisableDeadSoundStateForPlayer(false, lp_player);

    libSond_gf_HeroVOPlayHeroLine(libCore_ge_HeroVOEvents_Revive, lp_player, libCore_gv_playerGroupFromPlayer[lp_player]);

    UnitRemove(libGame_gv_players[lp_player].lv_cameraDeadUnitCameraTarget);

    libGame_gv_players[lp_player].lv_cameraDeadUnitCameraTarget = null;

    libGame_gv_players[lp_player].lv_cameraPlayerUnitGroupToFocusOn = libNtve_gf_ConvertUnitToUnitGroup(lv_dVaMechUnit);

    libGame_gf_CameraUpdateCameraForPlayer(lp_player);

    UnitSetPropertyFixed(lv_dVaMechUnit, c_unitPropLifePercent, lp_respawnedMechHealthPercentage);

    UnitSetPropertyFixed(lv_dVaMechUnit, c_unitPropEnergy, (UnitGetPropertyFixed(lv_dVaMechUnit, c_unitPropEnergyMax, c_unitPropCurrent) - PlayerGetChargeUsed(lp_player, "Abil/DVaMechSelfDestruct")));

    libUIUI_gf_UIHeroConsoleShowHideUnitStatusFrameForPlayer(true, lp_player);

    libNtve_gf_MakeUnitUncommandable(lv_dVaMechUnit, false);

    CatalogFieldValueSet(c_gameCatalogAbil, "Mount", "CastIntroTime[" + IntToString(0) + "]", lp_player, CatalogFieldValueGet(c_gameCatalogAbil, "Mount", "CastIntroTime[" + IntToString(0) + "]", 0));

    CatalogFieldValueSet(c_gameCatalogAbil, "Mount", "Cost[" + IntToString(0) + "].Cooldown.TimeUse", lp_player, CatalogFieldValueGet(c_gameCatalogAbil, "Mount", "Cost.Cooldown.TimeUse", 0));

    AIRemovePlayerUnit(lv_dVaPilotUnit);

    AIAddPlayerUnit(lv_dVaMechUnit);

    libUIUI_gv_uIHeroStatusFrames[lp_player].lv_unitCount = 0;

    libHDVA_gf_DVaUpdatethePartyFrametoActiveUnit(lp_player);

    libAIAI_gf_AITeamDelegateModifyHeroStatusTokensforTeam(libAIAI_ge_AITeamDelegateAddRemoveLaneValue_Add, libGame_gv_players[lp_player].lv_aIHeroDelegateTokenValue, libGame_gf_TeamNumberOfPlayer(lp_player), libAIAI_ge_AITeamDelegateLivingDeadHeroStatusUpdates_HeroAlive);

    libAIAI_gf_AITeamDelegateModifyHeroStatusTokensforTeam(libAIAI_ge_AITeamDelegateAddRemoveLaneValue_Remove, libGame_gv_players[lp_player].lv_aIHeroDelegateTokenValue, libGame_gf_TeamNumberOfPlayer(lp_player), libAIAI_ge_AITeamDelegateLivingDeadHeroStatusUpdates_HeroDead);

    Wait(0.0625, c_timeGame);

    UnitCreateEffectUnit(lv_dVaPilotUnit, "DVaTransferMapMechanicStacksBlackhearts", lv_dVaMechUnit);

    return true;

}



void libHDVA_gf_DVaPilotUpdateEnergy (int lp_dVaPlayer) {

    // Variable Declarations

    unit lv_dVaPilotUnit;

    unit lv_dVaMechUnit;

    fixed lv_calculatedEnergyAmount;

    fixed lv_durationMax;

    fixed lv_durationRemain;



    // Automatic Variable Declarations

    // Variable Initialization



    // Implementation

    if (((lp_dVaPlayer < 1) || (lp_dVaPlayer > libCore_gv_bALMaxPlayers) || (UnitGetType(libGame_gv_players[lp_dVaPlayer].lv_heroUnit) != "HeroDVaPilot"))) {

        return ;

    }



    lv_dVaPilotUnit = libGame_gv_players[lp_dVaPlayer].lv_heroUnit;

    if ((UnitHasBehavior2(lv_dVaPilotUnit, "DVaPilotDisableCallMech") == true)) {

        lv_dVaMechUnit = UnitBehaviorEffectUnit(lv_dVaPilotUnit, "DVaPilotDisableCallMech", c_effectUnitCaster, 0);

        lv_durationMax = UnitBehaviorDurationTotal(lv_dVaMechUnit, "DVaMechCallMechDisabler");

        lv_durationRemain = UnitBehaviorDuration(lv_dVaMechUnit, "DVaMechCallMechDisabler");

        if ((lv_durationRemain > 0.05)) {

            lv_calculatedEnergyAmount = ((1.0 - (lv_durationRemain / lv_durationMax)) * 100.0);

        }

        else {

            return ;

        }

    }

    else {

        lv_durationMax = libHDVA_gv_dVaCallMechDefaultMaxCooldown;

        lv_durationRemain = PlayerGetCooldown(lp_dVaPlayer, "Abil/DVaPilotCallMech");

        if ((PlayerHasTalent(lp_dVaPlayer, "DVaFullMetal") == true)) {

            lv_calculatedEnergyAmount = ((1.0 - (lv_durationRemain / (lv_durationMax + libHDVA_gv_dVaCallMechFullMetalCooldownChange))) * 100.0);

        }

        else {

            lv_calculatedEnergyAmount = ((1.0 - (lv_durationRemain / lv_durationMax)) * 100.0);

        }

    }

    UnitSetPropertyFixed(lv_dVaPilotUnit, c_unitPropEnergy, lv_calculatedEnergyAmount);

}



void libHDVA_gf_DVaUpdatethePartyFrametoActiveUnit (int lp_dVaPlayer) {

    // Variable Declarations

    int lv_owningFaction;

    int lv_playerPartyFrameDialog;

    int lv_teamPartyFrameDialog;

    int lv_playerRoster;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_owningFaction = libGame_gf_TeamNumberOfPlayer(lp_dVaPlayer);

    lv_playerPartyFrameDialog = c_invalidDialogControlId;

    lv_teamPartyFrameDialog = c_invalidDialogControlId;

    lv_playerRoster = lp_dVaPlayer;



    // Implementation

    lv_owningFaction = libGame_gf_TeamNumberOfPlayer(lp_dVaPlayer);

    DialogControlHookup(libHDVA_gv_dVaUI.lv_partyFrame, c_triggerControlTypePanel, "Team" + IntToString(lv_owningFaction) + "HeroOverview");

    lv_teamPartyFrameDialog = DialogControlLastCreated();

    lv_playerRoster = lp_dVaPlayer;

    if ((lv_playerRoster > libCore_gv_bALMaxPlayersOnATeam)) {

        lv_playerRoster = (lv_playerRoster - libCore_gv_bALMaxPlayersOnATeam);

    }



    DialogControlHookup(lv_teamPartyFrameDialog, c_triggerControlTypePanel, "HeroOverview" + IntToString(lv_playerRoster) + "/HeroUnitStatusFramePinkEnergy");

    lv_playerPartyFrameDialog = DialogControlLastCreated();

    if ((UnitGetType(libHDVA_gf_HeroDVaActiveDVaUnit(lp_dVaPlayer)) == "HeroDVaPilot")) {

        libNtve_gf_SetDialogItemUnit(lv_playerPartyFrameDialog, libGame_gv_players[lp_dVaPlayer].lv_heroUnit, PlayerGroupActive());

        libNtve_gf_SetDialogItemUnit(libUIUI_gv_uIPartyFrame.lv_heroPartyButton[libUIUI_gf_UIPartyFrameUIIndexofHeroUnit(libGame_gv_players[lp_dVaPlayer].lv_heroUnit, lp_dVaPlayer)], libGame_gv_players[lp_dVaPlayer].lv_heroUnit, PlayerGroupAll());

        libUIUI_gf_UIPartyFrameSetDVaFrame(lp_dVaPlayer, false);

    }

    else {

        libNtve_gf_SetDialogItemUnit(lv_playerPartyFrameDialog, UnitTransport(libGame_gv_players[lp_dVaPlayer].lv_heroUnit), PlayerGroupActive());

        libNtve_gf_SetDialogItemUnit(libUIUI_gv_uIPartyFrame.lv_heroPartyButton[libUIUI_gf_UIPartyFrameUIIndexofHeroUnit(libGame_gv_players[lp_dVaPlayer].lv_heroUnit, lp_dVaPlayer)], UnitTransport(libGame_gv_players[lp_dVaPlayer].lv_heroUnit), PlayerGroupAll());

        libUIUI_gf_UIPartyFrameSetDVaFrame(lp_dVaPlayer, true);

    }

}



unit libHDVA_gf_HeroDVaActiveDVaUnit (int lp_playerID) {

    // Variable Declarations

    unit lv_pilotUnit;

    unit lv_mechUnit;



    // Automatic Variable Declarations

    // Variable Initialization



    // Implementation

    lv_pilotUnit = libGame_gv_players[lp_playerID].lv_heroUnit;

    if ((UnitGetType(lv_pilotUnit) == "HeroDVaPilot")) {

        if ((libNtve_gf_UnitIsInsideTransport(lv_pilotUnit) == false)) {

            return lv_pilotUnit;

        }

        else {

            lv_mechUnit = UnitTransport(lv_pilotUnit);

            if ((UnitGetType(lv_mechUnit) == "HeroDVaMech")) {

                return lv_mechUnit;

            }

            else {

                return lv_pilotUnit;

            }

        }

    }

    else {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_HDVA_13ABE3CF"), true);

        return null;

    }

}



// Triggers

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

// Trigger: Mod Initialization

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

bool libHDVA_gt_ModInitialization_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Actions

    if (!runActions) {

        return true;

    }



    libCore_gf_DataHeroesAddManualSpawnHero(libCore_gf_GetIndexFromHero("DVa"), false, false);

    libHDVA_gf_HeroDVaUIInitialize();

    return true;

}



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

void libHDVA_gt_ModInitialization_Init () {

    libHDVA_gt_ModInitialization = TriggerCreate("libHDVA_gt_ModInitialization_Func");

    libCore_gf_IncludeModInitialization(libHDVA_gt_ModInitialization);

}



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

// Trigger: Hero - D.Va - Manual Spawn

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

bool libHDVA_gt_HeroDVaManualSpawn_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libGame_gf_ManualHeroSpawnHeroID() == libCore_gf_GetIndexFromHero("DVa")))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libGame_gv_players[libGame_gf_ManualHeroSpawnPlayer()].lv_heroRequiresCustomRespawn = true;

    libHDVA_gf_SpawnDVa(libGame_gf_ManualHeroSpawnPlayer(), libGame_gf_ManualHeroSpawnHeroID(), libGame_gf_ManualHeroSpawnLocation());

    libGame_gf_GrantXPToPlayer(libGame_gf_ManualHeroSpawnDebugXP(), libGame_gf_ManualHeroSpawnPlayer(), libGame_ge_XPSources_Debug);

    return true;

}



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

void libHDVA_gt_HeroDVaManualSpawn_Init () {

    libHDVA_gt_HeroDVaManualSpawn = TriggerCreate("libHDVA_gt_HeroDVaManualSpawn_Func");

    libGame_gf_ManualHeroSpawn(libHDVA_gt_HeroDVaManualSpawn);

}



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

// Trigger: D.Va - Respawn

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

bool libHDVA_gt_DVaRespawn_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_dVaPilotUnit;



    // Automatic Variable Declarations

    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((UnitGetType(libGame_gv_players[libGame_gf_RequestCustomRespawnPlayer()].lv_heroUnit) == "HeroDVaPilot"))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    lv_dVaPilotUnit = libGame_gv_players[libGame_gf_RequestCustomRespawnPlayer()].lv_heroUnit;

    libHDVA_gf_RespawnHeroDVa(lv_dVaPilotUnit, libGame_gf_RequestCustomRespawnPlayer(), libGame_gf_RequestCustomRespawnRespawnLocation(), libGame_gf_RequestCustomRespawnRespawnHealthPercent());

    return true;

}



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

void libHDVA_gt_DVaRespawn_Init () {

    libHDVA_gt_DVaRespawn = TriggerCreate("libHDVA_gt_DVaRespawn_Func");

    libGame_gf_RequestCustomRespawn(libHDVA_gt_DVaRespawn);

}



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

// Trigger: D.Va - Respawn - Auriel Light Speed Special Case

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

bool libHDVA_gt_DVaRespawnAurielLightSpeedSpecialCase_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_dVaPlayer;

    unit lv_aurielUnit;



    // Automatic Variable Declarations

    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((UnitGetType(UnitBehaviorEffectUnit(EventUnit(), EventUnitBehavior(), c_effectUnitTarget, 0)) == "HeroDVaPilot"))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    lv_dVaPlayer = UnitGetOwner(UnitBehaviorEffectUnit(EventUnit(), EventUnitBehavior(), c_effectUnitTarget, 0));

    lv_aurielUnit = UnitBehaviorEffectUnit(EventUnit(), EventUnitBehavior(), c_effectUnitCaster, 0);

    Wait(0.0625, c_timeGame);

    UnitCreateEffectUnit(lv_aurielUnit, "AurielResurrectLightSpeedApplyControllerBehavior", libAIAI_gv_aIHeroes[lv_dVaPlayer].lv_currentHeroUnit);

    return true;

}



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

void libHDVA_gt_DVaRespawnAurielLightSpeedSpecialCase_Init () {

    libHDVA_gt_DVaRespawnAurielLightSpeedSpecialCase = TriggerCreate("libHDVA_gt_DVaRespawnAurielLightSpeedSpecialCase_Func");

    TriggerAddEventUnitBehaviorChange(libHDVA_gt_DVaRespawnAurielLightSpeedSpecialCase, null, "AurielResurrectLightSpeedControllerBehavior", c_unitBehaviorChangeCreate);

}



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

// Trigger: D.Va - Moonwell Redistribution

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

bool libHDVA_gt_DVaMoonwellRedistribution_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_mech;

    unit lv_moonwell;

    unit lv_pilot;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_mech = EventPlayerEffectUsedUnit(c_effectUnitCaster);

    lv_moonwell = EventPlayerEffectUsedUnit(c_effectUnitTarget);



    // Conditions

    if (testConds) {

        if (!((UnitGetType(lv_mech) == "HeroDVaMech"))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    lv_pilot = UnitCargo(lv_mech, 1);

    UnitBehaviorAdd(lv_pilot, "HealingFountainCooldown", lv_mech, 1);

    UnitCreateEffectUnit(lv_pilot, "FountainApplySet", lv_pilot);

    if ((EventPlayerEffectUsed() == "MoonwellDrinkStartingSet") && (PlayerGetCooldown(UnitGetOwner(lv_mech), "Abil/DVaLiquidCoolingAbility") < 50.0)) {

        UnitCreateEffectUnit(lv_mech, "DVaLiquidCoolingModifyCooldown", lv_mech);

    }



    return true;

}



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

void libHDVA_gt_DVaMoonwellRedistribution_Init () {

    libHDVA_gt_DVaMoonwellRedistribution = TriggerCreate("libHDVA_gt_DVaMoonwellRedistribution_Func");

    TriggerEnable(libHDVA_gt_DVaMoonwellRedistribution, false);

    TriggerAddEventPlayerEffectUsed(libHDVA_gt_DVaMoonwellRedistribution, c_playerAny, "MoonwellDrinkStartingSet");

    TriggerAddEventPlayerEffectUsed(libHDVA_gt_DVaMoonwellRedistribution, c_playerAny, "DVaLiquidCoolingCastSet");

}



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

// Trigger: D.Va - Cargo Unloaded - Selection Control

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

bool libHDVA_gt_DVaCargoUnloadedSelectionControl_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_dVaPlayer;

    unit lv_dVaPilot;

    unit lv_dVaMech;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_dVaPlayer = EventPlayer();

    lv_dVaPilot = EventUnitCargo();

    lv_dVaMech = EventUnit();



    // Conditions

    if (testConds) {

        if (!((UnitGetType(lv_dVaPilot) == "HeroDVaPilot"))) {

            return false;

        }



        if (!((UnitGetType(lv_dVaMech) == "HeroDVaMech"))) {

            return false;

        }



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

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    UnitSelect(lv_dVaMech, lv_dVaPlayer, false);

    UnitSelect(lv_dVaPilot, lv_dVaPlayer, true);

    UnitGroupRemove(libGame_gv_players[lv_dVaPlayer].lv_heroUnitGroup, lv_dVaMech);

    libGame_gv_players[lv_dVaPlayer].lv_cameraPlayerUnitGroupToFocusOn = libNtve_gf_ConvertUnitToUnitGroup(lv_dVaPilot);

    libGame_gf_CameraUpdateCameraForPlayer(lv_dVaPlayer);

    libUIUI_gf_UIHeroConsoleSetUpForPlayer(lv_dVaPilot, lv_dVaPlayer);

    libUIUI_gf_HeroConsoleUnitStatusBarsSetUnitForBars(lv_dVaPilot, lv_dVaPlayer);

    libGame_gf_SendEventHeroUnitSwappedForPlayer(lv_dVaMech, lv_dVaPilot, lv_dVaPlayer, false);

    libGame_gf_SendEventCheckUnitForAbilityRedirect(lv_dVaMech, lv_dVaPilot, false, UnitGetPosition(lv_dVaMech));

    libUIUI_gf_InitPathingLines(lv_dVaPilot, lv_dVaPlayer);

    libAIAI_gv_aIHeroes[lv_dVaPlayer].lv_currentHeroUnit = lv_dVaPilot;

    libHDVA_gf_DVaUpdatethePartyFrametoActiveUnit(lv_dVaPlayer);

    AIRemovePlayerUnit(lv_dVaMech);

    AIAddPlayerUnit(lv_dVaPilot);

    libUIUI_gv_uIHeroStatusFrames[lv_dVaPlayer].lv_unitCount = 0;

    libUIUI_gf_UIUnitStatusFramesUpdateUnitStatusFramesForUnit(lv_dVaPlayer, lv_dVaPilot);

    PlayerSetHeroUnit(lv_dVaPlayer, lv_dVaPilot);

    return true;

}



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

void libHDVA_gt_DVaCargoUnloadedSelectionControl_Init () {

    libHDVA_gt_DVaCargoUnloadedSelectionControl = TriggerCreate("libHDVA_gt_DVaCargoUnloadedSelectionControl_Func");

    TriggerEnable(libHDVA_gt_DVaCargoUnloadedSelectionControl, false);

    TriggerAddEventUnitCargo(libHDVA_gt_DVaCargoUnloadedSelectionControl, null, false);

}



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

// Trigger: D.Va - Abathur Creates a D.Va Clone

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

bool libHDVA_gt_DVaAbathurCreatesaDVaClone_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_clonedDVaUnit;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_clonedDVaUnit = libGame_gv_players[libGDHL_gf_AbathurUltimateEvolutionHeroCopiedAbathurOwner()].lv_activeVehicle;



    // Conditions

    if (testConds) {

        if (!((UnitGetType(libGame_gv_players[libGDHL_gf_AbathurUltimateEvolutionHeroCopiedTargetOwner()].lv_heroUnit) == "HeroDVaPilot"))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((UnitGetType(lv_clonedDVaUnit) == "HeroDVaPilot")) {

        UnitBehaviorRemove(lv_clonedDVaUnit, "DVaPilotSpawningAbilityDisabler", 1);

    }

    else {

        UnitBehaviorRemove(lv_clonedDVaUnit, "DVaMechNoCargoStatusBarHidden", 1);

    }

    return true;

}



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

void libHDVA_gt_DVaAbathurCreatesaDVaClone_Init () {

    libHDVA_gt_DVaAbathurCreatesaDVaClone = TriggerCreate("libHDVA_gt_DVaAbathurCreatesaDVaClone_Func");

    TriggerEnable(libHDVA_gt_DVaAbathurCreatesaDVaClone, false);

    libGDHL_gf_AbathurUltimateEvolutionHeroCopied(libHDVA_gt_DVaAbathurCreatesaDVaClone);

}



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

// Trigger: D.Va - Abathur Cloned Mech Ends

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

bool libHDVA_gt_DVaAbathurClonedMechEnds_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_clonedUnit;

    int lv_abathurPlayer;

    fixed lv_selfDestructChargeMax;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_clonedUnit = libGDHL_gf_AbathurUltimateEvolutionEndedClonedUnit();

    lv_abathurPlayer = libGDHL_gf_AbathurUltimateEvolutionEndedAbathurPlayer();

    lv_selfDestructChargeMax = CatalogFieldValueGetAsFixed(c_gameCatalogAbil, "DVaMechSelfDestruct", "Cost.Charge.CountMax", lv_abathurPlayer);



    // Conditions

    if (testConds) {

        if (!((UnitGetType(lv_clonedUnit) == "HeroDVaMech"))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    PlayerAddChargeUsed(lv_abathurPlayer, "Abil/DVaMechSelfDestruct", (lv_selfDestructChargeMax - PlayerGetChargeUsed(lv_abathurPlayer, "Abil/DVaMechSelfDestruct")));

    return true;

}



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

void libHDVA_gt_DVaAbathurClonedMechEnds_Init () {

    libHDVA_gt_DVaAbathurClonedMechEnds = TriggerCreate("libHDVA_gt_DVaAbathurClonedMechEnds_Func");

    TriggerEnable(libHDVA_gt_DVaAbathurClonedMechEnds, false);

    libGDHL_gf_AbathurUltimateEvolutionEnded(libHDVA_gt_DVaAbathurClonedMechEnds);

}



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

// Trigger: Hero - D.Va - Pilot Ejected - Move Command Forwarding

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

bool libHDVA_gt_HeroDVaPilotEjectedMoveCommandForwarding_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_dVaPilot;

    unit lv_dVaMech;

    int lv_dVaPlayer;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_dVaPilot = EventPlayerEffectUsedUnit(c_effectUnitTarget);

    lv_dVaMech = EventPlayerEffectUsedUnit(c_effectUnitCaster);

    lv_dVaPlayer = UnitGetOwner(lv_dVaPilot);



    // Actions

    if (!runActions) {

        return true;

    }



    libUIUI_gf_FullscreenOverlayStopandClearCutsceneQueueForPlayer(lv_dVaPlayer);

    UnitOrderCopy(lv_dVaMech, lv_dVaPilot, 32);

    return true;

}



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

void libHDVA_gt_HeroDVaPilotEjectedMoveCommandForwarding_Init () {

    libHDVA_gt_HeroDVaPilotEjectedMoveCommandForwarding = TriggerCreate("libHDVA_gt_HeroDVaPilotEjectedMoveCommandForwarding_Func");

    TriggerEnable(libHDVA_gt_HeroDVaPilotEjectedMoveCommandForwarding, false);

    TriggerAddEventPlayerEffectUsed(libHDVA_gt_HeroDVaPilotEjectedMoveCommandForwarding, c_playerAny, "DVaMechPilotUnloadSet");

}



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

// Trigger: Hero - D.Va - Mech Dies via Fatal Damage

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

bool libHDVA_gt_HeroDVaMechDiesviaFatalDamage_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_unit;

    int lv_targetPlayer;

    unit lv_killingUnit;

    int lv_killingPlayer;

    playergroup lv_enemyPlayerGroup;

    int lv_itPlayer;

    playergroup lv_killingGroup;

    int lv_killingFaction;



    // Automatic Variable Declarations

    playergroup autoE02018F0_g;



    // Variable Initialization

    lv_unit = EventUnit();

    lv_targetPlayer = UnitGetOwner(lv_unit);

    lv_killingUnit = EventPlayerEffectUsedUnit(c_effectUnitTarget);

    lv_killingPlayer = EventUnitDamageSourcePlayer();

    lv_enemyPlayerGroup = PlayerGroupEmpty();

    lv_killingGroup = PlayerGroupEmpty();



    // Conditions

    if (testConds) {

        if (!((UnitGetType(libGame_gv_players[lv_targetPlayer].lv_heroUnit) != "HeroAbathur"))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libGame_gf_DeathRecapPopulateDeathRecapDataForPlayer(lv_unit, lv_targetPlayer);

    lv_enemyPlayerGroup = libGame_gf_EnemyPlayerGroupOfPlayer(lv_targetPlayer);

    lv_killingGroup = libGame_gf_HeroDeathGetKillingGroupFromKillingTeamGroupAndDeadUnit(lv_enemyPlayerGroup, lv_killingPlayer, lv_unit);

    libGame_gf_HeroDeathAwardXP(lv_killingPlayer, lv_unit, lv_enemyPlayerGroup, lv_killingGroup, true);

    if ((UnitGroupCount(UnitGroupAlliance(lv_targetPlayer, c_unitAllianceEnemy, RegionCircle(UnitGetPosition(lv_unit), libCore_gv_bALHeroKillXPRadius), libCore_gv_filtersHeroic, libCore_gv_bALMaxPlayersOnATeam), c_unitCountAlive) >= 1)) {

        autoE02018F0_g = lv_killingGroup;

        lv_itPlayer = -1;

        while (true) {

            	lv_itPlayer = PlayerGroupNextPlayer(autoE02018F0_g, lv_itPlayer);

            	if (lv_itPlayer<0) { break; }

            	libGame_gf_ScoreValuesRecordXPContributionForPlayer(lv_itPlayer, (libCore_gf_DataXPXPForHero(lv_itPlayer, lv_unit) / PlayerGroupCount(lv_killingGroup)), false);

            libGame_gf_SendEventHeroParticipatedInTakedown(lv_killingPlayer, lv_itPlayer, lv_targetPlayer, lv_unit, UnitGetPosition(lv_unit));

        }

    }



    libUIUI_gf_KillLogAnnounceKill(lv_killingPlayer, lv_unit);

    return true;

}



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

void libHDVA_gt_HeroDVaMechDiesviaFatalDamage_Init () {

    libHDVA_gt_HeroDVaMechDiesviaFatalDamage = TriggerCreate("libHDVA_gt_HeroDVaMechDiesviaFatalDamage_Func");

    TriggerEnable(libHDVA_gt_HeroDVaMechDiesviaFatalDamage, false);

    TriggerAddEventUnitDamageAbsorbed(libHDVA_gt_HeroDVaMechDiesviaFatalDamage, null, "DVaMechFatalDamageResponse");

}



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

// Trigger: Hero - D.Va - Micro Missiles Active

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

bool libHDVA_gt_HeroDVaMicroMissilesActive_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_i;

    unit lv_dVa;

    fixed lv_angle;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_i = 3;

    lv_dVa = EventPlayerEffectUsedUnit(c_effectUnitCaster);

    lv_angle = AngleBetweenPoints(UnitGetPosition(lv_dVa), EventPlayerEffectUsedPoint(c_effectLocationTargetPoint));



    // Actions

    if (!runActions) {

        return true;

    }



    Wait(0.3125, c_timeGame);

    while ((UnitBehaviorCount(lv_dVa, "DVaMicroMissilesCasterBuff") == 1)) {

        if ((lv_i >= 3)) {

            UnitCreateEffectPoint(lv_dVa, "DVaMicroMissilesLeftLaunchPersistent", PointWithOffsetPolar(UnitGetPosition(lv_dVa), 13.0, lv_angle));

            UnitCreateEffectPoint(lv_dVa, "DVaMicroMissilesRightLaunchPersistent", PointWithOffsetPolar(UnitGetPosition(lv_dVa), 13.0, lv_angle));

            lv_i = 0;

            lv_i += 1;

        }

        else {

            lv_i += 1;

        }

        if ((UnitHasBehaviorWithCategoryFlag(lv_dVa, c_behaviorCategoryTimeStop) == true)) {

            while (!((UnitHasBehaviorWithCategoryFlag(lv_dVa, c_behaviorCategoryTimeStop) == false))) {

                Wait(0.0625, c_timeGame);

            }

        }

        else {

            Wait(0.0625, c_timeGame);

        }

    }

    return true;

}



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

void libHDVA_gt_HeroDVaMicroMissilesActive_Init () {

    libHDVA_gt_HeroDVaMicroMissilesActive = TriggerCreate("libHDVA_gt_HeroDVaMicroMissilesActive_Func");

    TriggerEnable(libHDVA_gt_HeroDVaMicroMissilesActive, false);

    TriggerAddEventPlayerEffectUsed(libHDVA_gt_HeroDVaMicroMissilesActive, c_playerAny, "DVaMicroMissilesCastSet");

}



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

// Trigger: D.Va - Boosters - Enemy Hall of Storms

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

bool libHDVA_gt_DVaBoostersEnemyHallofStorms_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_dVaUnit;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_dVaUnit = libGame_gf_UnitEntersSafeZonePuntRegionUnit();



    // Conditions

    if (testConds) {

        if (!((UnitGetType(lv_dVaUnit) == "HeroDVaMech"))) {

            return false;

        }



        if (!((UnitGroupCount(UnitCargoGroup(lv_dVaUnit), c_unitCountAlive) == 0))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    UnitBehaviorRemove(lv_dVaUnit, "DVaBoostersActive", 1);

    UnitIssueOrder(lv_dVaUnit, Order(AbilityCommand("stop", 0)), c_orderQueueReplace);

    return true;

}



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

void libHDVA_gt_DVaBoostersEnemyHallofStorms_Init () {

    libHDVA_gt_DVaBoostersEnemyHallofStorms = TriggerCreate("libHDVA_gt_DVaBoostersEnemyHallofStorms_Func");

    TriggerEnable(libHDVA_gt_DVaBoostersEnemyHallofStorms, false);

    libGame_gf_UnitEntersSafeZonePuntRegion(libHDVA_gt_DVaBoostersEnemyHallofStorms);

}



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

// Trigger: D.Va - Defense Matrix - Tracker

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

bool libHDVA_gt_DVaDefenseMatrixTracker_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_damagedUnit;

    unit lv_dVaUnit;

    int lv_dVaPlayer;

    fixed lv_damageAmount;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_damagedUnit = EventUnitDamageSourceUnit();

    lv_dVaUnit = EventUnitBehaviorCasterUnit();

    lv_dVaPlayer = UnitGetOwner(lv_dVaUnit);

    lv_damageAmount = EventUnitDamageAbsorbed();



    // Conditions

    if (testConds) {

        if (!((lv_dVaPlayer > 0))) {

            return false;

        }



        if (!((lv_dVaPlayer <= libCore_gv_bALMaxPlayers))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    PlayerScoreValueSetFromFixed(lv_dVaPlayer, "DVaDefenseMatrixTotalDamagePrevented", (PlayerScoreValueGetAsFixed(lv_dVaPlayer, "DVaDefenseMatrixTotalDamagePrevented") + lv_damageAmount));

    if ((UnitFilterMatch(lv_damagedUnit, lv_dVaPlayer, libCore_gv_filtersHeroic) == true)) {

        PlayerScoreValueSetFromFixed(lv_dVaPlayer, "DVaDefenseMatrixTotalDamagePreventedToHeroes", (PlayerScoreValueGetAsFixed(lv_dVaPlayer, "DVaDefenseMatrixTotalDamagePreventedToHeroes") + lv_damageAmount));

    }



    if (((UnitHasBehavior2(lv_dVaUnit, "DVaMechDefenseMatrixChannelling") == true) || (UnitHasBehavior2(lv_dVaUnit, "DVaDefenseMatrixDummyContinuation") == true))) {

        PlayerScoreValueSetFromFixed(lv_dVaPlayer, "DVaDefenseMatrixDamagePreventedCurrentMatrix", (PlayerScoreValueGetAsFixed(lv_dVaPlayer, "DVaDefenseMatrixDamagePreventedCurrentMatrix") + lv_damageAmount));

    }



    return true;

}



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

void libHDVA_gt_DVaDefenseMatrixTracker_Init () {

    libHDVA_gt_DVaDefenseMatrixTracker = TriggerCreate("libHDVA_gt_DVaDefenseMatrixTracker_Func");

    TriggerEnable(libHDVA_gt_DVaDefenseMatrixTracker, false);

    TriggerAddEventUnitDamageAbsorbed(libHDVA_gt_DVaDefenseMatrixTracker, null, "DVaMechDefenseMatrixDebuff");

}



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

// Trigger: D.Va - Defense Matrix - Tracker Report and Reset

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

bool libHDVA_gt_DVaDefenseMatrixTrackerReportandReset_Func (bool testConds, bool runActions) {

    // Variable Declarations

    fixed lv_damageAmount;

    unit lv_dVaUnit;

    int lv_dVaPlayer;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_dVaUnit = EventUnitBehaviorChangeCasterUnit();

    lv_dVaPlayer = UnitGetOwner(lv_dVaUnit);



    // Conditions

    if (testConds) {

        if (!((lv_dVaPlayer > 0))) {

            return false;

        }



        if (!((lv_dVaPlayer <= libCore_gv_bALMaxPlayers))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((EventUnitBehaviorChange() == c_unitBehaviorChangeIncrease)) {

        if ((PlayerScoreValueGetAsFixed(lv_dVaPlayer, "DVaDefenseMatrixDamagePreventedCurrentMatrix") > 0)) {

            TextExpressionSetToken("Param/Expression/lib_HDVA_B9A3D392", "A", FixedToText(PlayerScoreValueGetAsFixed(lv_dVaPlayer, "DVaDefenseMatrixDamagePreventedCurrentMatrix"), 0));

            FloatingCombatElementCreateTextAtUnit(PlayerGroupSingle(lv_dVaPlayer), "FloatingCombatElements/FloatingCombatAmountReadable", "", lv_dVaUnit, TextExpressionAssemble("Param/Expression/lib_HDVA_B9A3D392"), libNtve_gv_FloatingCombatTextAutoRandomSeed);

        }



    }

    else {

        PlayerScoreValueSetFromFixed(lv_dVaPlayer, "DVaDefenseMatrixDamagePreventedCurrentMatrix", 0.0);

    }

    return true;

}



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

void libHDVA_gt_DVaDefenseMatrixTrackerReportandReset_Init () {

    libHDVA_gt_DVaDefenseMatrixTrackerReportandReset = TriggerCreate("libHDVA_gt_DVaDefenseMatrixTrackerReportandReset_Func");

    TriggerEnable(libHDVA_gt_DVaDefenseMatrixTrackerReportandReset, false);

    TriggerAddEventUnitBehaviorChange(libHDVA_gt_DVaDefenseMatrixTrackerReportandReset, null, "DVaDefenseMatrixDummyContinuation", c_unitBehaviorChangeIncrease);

    TriggerAddEventUnitBehaviorChange(libHDVA_gt_DVaDefenseMatrixTrackerReportandReset, null, "DVaDefenseMatrixDummyContinuation", c_unitBehaviorChangeDecrease);

}



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

// Trigger: D.Va - Damage Taken - Self Destruct Charge

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

bool libHDVA_gt_DVaDamageTakenSelfDestructCharge_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_dVaPlayer;

    fixed lv_damageTakenPercent;

    unit lv_dVaMechUnit;

    fixed lv_incomingDamageAmount;

    fixed lv_maxMechHealth;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_dVaPlayer = UnitGetOwner(EventUnit());

    lv_dVaMechUnit = EventUnit();

    lv_maxMechHealth = UnitGetPropertyFixed(lv_dVaMechUnit, c_unitPropLifeMax, c_unitPropCurrent);



    // Conditions

    if (testConds) {

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

            return false;

        }



        if (!((UnitHasBehavior2(lv_dVaMechUnit, "DVaMechSelfDestructAbandoned") == false))) {

            return false;

        }



        if (!((PlayerGetChargeUsed(lv_dVaPlayer, "Abil/DVaMechSelfDestruct") > 0.0))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    lv_incomingDamageAmount = (EventUnitDamageAmount() + EventUnitDamageBehaviorShield());

    if ((UnitHasBehavior2(EventUnitDamageSourceUnit(), "DVaMechDefenseMatrixDebuff") == true)) {

        if ((CatalogFieldValueGet(c_gameCatalogEffect, EventUnitDamageEffect(), "Aliases[" + IntToString(0) + "]", c_playerAny) == "PercentDamage")) {

        }

        else {

            lv_incomingDamageAmount /= 0.4;

        }

    }



    if ((PlayerHasTalent(lv_dVaPlayer, "DVaFullMetal") == true)) {

        lv_maxMechHealth = (lv_maxMechHealth / libHDVA_gv_dVaCallMechFullMetalHealthModifier);

    }



    lv_damageTakenPercent = ((lv_incomingDamageAmount / lv_maxMechHealth) * 100.0);

    lv_damageTakenPercent += libHDVA_gv_dVaDefensiveChargeRemainder[lv_dVaPlayer];

    while ((lv_damageTakenPercent > libHDVA_gv_dVASelfDestructHealthpercentageneededtogenerate1charge)) {

        PlayerAddChargeUsed(lv_dVaPlayer, "Abil/DVaMechSelfDestruct", -1.0);

        lv_damageTakenPercent -= libHDVA_gv_dVASelfDestructHealthpercentageneededtogenerate1charge;

    }

    UnitSetPropertyFixed(lv_dVaMechUnit, c_unitPropEnergy, (UnitGetPropertyFixed(lv_dVaMechUnit, c_unitPropEnergyMax, c_unitPropCurrent) - PlayerGetChargeUsed(lv_dVaPlayer, "Abil/DVaMechSelfDestruct")));

    libHDVA_gv_dVaDefensiveChargeRemainder[lv_dVaPlayer] = lv_damageTakenPercent;

    return true;

}



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

void libHDVA_gt_DVaDamageTakenSelfDestructCharge_Init () {

    libHDVA_gt_DVaDamageTakenSelfDestructCharge = TriggerCreate("libHDVA_gt_DVaDamageTakenSelfDestructCharge_Func");

    TriggerEnable(libHDVA_gt_DVaDamageTakenSelfDestructCharge, false);

    TriggerAddDamageEvent(libHDVA_gt_DVaDamageTakenSelfDestructCharge, null, "HeroDVaMech", c_unitDamageTypeAny, c_unitDamageEither, null);

}



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

// Trigger: D.Va - Call Mech

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

bool libHDVA_gt_DVaCallMech_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_playerPartyFrameDialog;

    int lv_teamPartyFrameDialog;

    int lv_owningFaction;

    int lv_playerRoster;

    unit lv_dVaPilotUnit;

    int lv_dVaPlayer;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_playerPartyFrameDialog = c_invalidDialogControlId;

    lv_teamPartyFrameDialog = c_invalidDialogControlId;

    lv_dVaPilotUnit = EventUnit();

    lv_dVaPlayer = UnitGetOwner(lv_dVaPilotUnit);



    // Actions

    if (!runActions) {

        return true;

    }



    UnitCreate(1, "HeroDVaMech", c_unitCreateIgnoreIslands, lv_dVaPlayer, PointWithOffsetPolar(UnitGetPosition(EventUnit()), libHDVA_gv_dVaCallMechSummonedMechTargetPointOffset_C, UnitGetFacing(EventUnit())), UnitGetFacing(lv_dVaPilotUnit), null);

    libHDVA_gv_dVaCallMechMechBeingSummoned[lv_dVaPlayer] = UnitLastCreated();

    if ((libHDVA_gv_dVaCallMechMechBeingSummoned[lv_dVaPlayer] != null)) {

        UnitCreateEffectUnit(lv_dVaPilotUnit, "DVaMechSpawnSet", libHDVA_gv_dVaCallMechMechBeingSummoned[lv_dVaPlayer]);

        UnitGroupAdd(libGame_gv_players[lv_dVaPlayer].lv_heroUnitGroup, libHDVA_gv_dVaCallMechMechBeingSummoned[lv_dVaPlayer]);

        UnitGroupAdd(libGame_gv_players[lv_dVaPlayer].lv_heroUnitGroup, lv_dVaPilotUnit);

        UnitBehaviorRemove(lv_dVaPilotUnit, "Mounted", 1);

        libNtve_gf_MakeUnitUncommandable(libHDVA_gv_dVaCallMechMechBeingSummoned[lv_dVaPlayer], true);

        UnitSetPropertyFixed(libHDVA_gv_dVaCallMechMechBeingSummoned[lv_dVaPlayer], c_unitPropEnergy, (UnitGetPropertyFixed(libHDVA_gv_dVaCallMechMechBeingSummoned[lv_dVaPlayer], c_unitPropEnergyMax, c_unitPropCurrent) - PlayerGetChargeUsed(lv_dVaPlayer, "Abil/DVaMechSelfDestruct")));

        UnitCreateEffectUnit(lv_dVaPilotUnit, "DVaMechCallMechApplyStun", libHDVA_gv_dVaCallMechMechBeingSummoned[lv_dVaPlayer]);

        UnitBehaviorAdd(libHDVA_gv_dVaCallMechMechBeingSummoned[lv_dVaPlayer], "CapturePointAllowed", libHDVA_gv_dVaCallMechMechBeingSummoned[lv_dVaPlayer], 1);

        Wait(CatalogFieldValueGetAsFixed(c_gameCatalogBehavior, "DVaMechCallMechStartingUpStun", "Duration", lv_dVaPlayer), c_timeGame);

        if ((UnitHasBehavior2(lv_dVaPilotUnit, "HealingFountainCooldown") == true)) {

            libNtve_gf_PlayerRemoveCooldown(lv_dVaPlayer, "Abil/DVaLiquidCoolingAbility");

            PlayerAddCooldown(lv_dVaPlayer, "Abil/DVaLiquidCoolingAbility", UnitBehaviorDuration(lv_dVaPilotUnit, "HealingFountainCooldown"));

        }



        UnitBehaviorRemove(libHDVA_gv_dVaCallMechMechBeingSummoned[lv_dVaPlayer], "CapturePointAllowed", c_unitBehaviorCountAll);

        if ((UnitHasBehavior2(lv_dVaPilotUnit, "IsHumanPlayer") == true)) {

            UnitBehaviorAdd(libHDVA_gv_dVaCallMechMechBeingSummoned[lv_dVaPlayer], "IsHumanPlayer", libHDVA_gv_dVaCallMechMechBeingSummoned[lv_dVaPlayer], 1);

        }



    }



    return true;

}



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

void libHDVA_gt_DVaCallMech_Init () {

    libHDVA_gt_DVaCallMech = TriggerCreate("libHDVA_gt_DVaCallMech_Func");

    TriggerEnable(libHDVA_gt_DVaCallMech, false);

    TriggerAddEventUnitAbility(libHDVA_gt_DVaCallMech, null, AbilityCommand("DVaPilotCallMech", 0), c_abilEffectStagePrep, false);

}



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

// Trigger: D.Va - Call Mech - Interrupted

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

bool libHDVA_gt_DVaCallMechInterrupted_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_dVaPilotUnit;



    // Automatic Variable Declarations

    // Variable Initialization



    // Actions

    if (!runActions) {

        return true;

    }



    lv_dVaPilotUnit = EventUnit();

    libNtve_gf_MakeUnitUncommandable(lv_dVaPilotUnit, false);

    UnitRemove(libHDVA_gv_dVaCallMechMechBeingSummoned[EventPlayer()]);

    UnitCreateEffectUnit(lv_dVaPilotUnit, "DVaPilotCallMechCancelOrder", lv_dVaPilotUnit);

    return true;

}



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

void libHDVA_gt_DVaCallMechInterrupted_Init () {

    libHDVA_gt_DVaCallMechInterrupted = TriggerCreate("libHDVA_gt_DVaCallMechInterrupted_Func");

    TriggerEnable(libHDVA_gt_DVaCallMechInterrupted, false);

    TriggerAddEventUnitAbility(libHDVA_gt_DVaCallMechInterrupted, null, AbilityCommand("DVaPilotCallMech", 0), c_abilEffectStageInterrupt, false);

    TriggerAddEventUnitAbility(libHDVA_gt_DVaCallMechInterrupted, null, AbilityCommand("DVaPilotCallMech", 0), c_abilEffectStageBail, false);

}



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

// Trigger: D.Va - Call Mech/MEKAfall - Completed

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

bool libHDVA_gt_DVaCallMechMEKAfallCompleted_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_dVaPlayer;

    unit lv_dVaMechUnit;

    unit lv_dVaPilotUnit;



    // Automatic Variable Declarations

    // Variable Initialization



    // Actions

    if (!runActions) {

        return true;

    }



    lv_dVaPilotUnit = EventUnit();

    lv_dVaPlayer = UnitGetOwner(lv_dVaPilotUnit);

    UnitPutInTransport(lv_dVaPilotUnit, libHDVA_gv_dVaCallMechMechBeingSummoned[lv_dVaPlayer]);

    UnitCreateEffectUnit(libHDVA_gv_dVaCallMechMechBeingSummoned[lv_dVaPlayer], "DVaTransferMapMechanicStacksLoadSet", lv_dVaPilotUnit);

    UnitBehaviorRemove(libHDVA_gv_dVaCallMechMechBeingSummoned[lv_dVaPlayer], "DVaMechForwardedTimeStop", 1);

    UnitSelect(lv_dVaPilotUnit, lv_dVaPlayer, false);

    UnitBehaviorRemove(lv_dVaPilotUnit, "AbathurSymbioteHostBehavior", 1);

    UnitSelect(libHDVA_gv_dVaCallMechMechBeingSummoned[lv_dVaPlayer], lv_dVaPlayer, true);

    libGame_gv_players[lv_dVaPlayer].lv_cameraPlayerUnitGroupToFocusOn = libNtve_gf_ConvertUnitToUnitGroup(libHDVA_gv_dVaCallMechMechBeingSummoned[lv_dVaPlayer]);

    libGame_gf_CameraUpdateCameraForPlayer(lv_dVaPlayer);

    libUIUI_gf_UIHeroConsoleSetUpForPlayer(libHDVA_gv_dVaCallMechMechBeingSummoned[lv_dVaPlayer], lv_dVaPlayer);

    libUIUI_gf_HeroConsoleUnitStatusBarsSetUnitForBars(libHDVA_gv_dVaCallMechMechBeingSummoned[lv_dVaPlayer], lv_dVaPlayer);

    UnitSetPropertyFixed(lv_dVaMechUnit, c_unitPropEnergy, (UnitGetPropertyFixed(libHDVA_gv_dVaCallMechMechBeingSummoned[lv_dVaPlayer], c_unitPropEnergyMax, c_unitPropCurrent) - PlayerGetChargeUsed(lv_dVaPlayer, "Abil/DVaMechSelfDestruct")));

    libGame_gf_SendEventHeroUnitSwappedForPlayer(lv_dVaPilotUnit, libHDVA_gv_dVaCallMechMechBeingSummoned[lv_dVaPlayer], lv_dVaPlayer, false);

    libGame_gf_SendEventCheckUnitForAbilityRedirect(lv_dVaPilotUnit, libHDVA_gv_dVaCallMechMechBeingSummoned[lv_dVaPlayer], false, UnitGetPosition(lv_dVaPilotUnit));

    libUIUI_gf_InitPathingLines(libHDVA_gv_dVaCallMechMechBeingSummoned[lv_dVaPlayer], lv_dVaPlayer);

    libNtve_gf_MakeUnitUncommandable(libHDVA_gv_dVaCallMechMechBeingSummoned[lv_dVaPlayer], false);

    libAIAI_gv_aIHeroes[lv_dVaPlayer].lv_currentHeroUnit = libHDVA_gv_dVaCallMechMechBeingSummoned[lv_dVaPlayer];

    CatalogFieldValueSet(c_gameCatalogAbil, "Mount", "CastIntroTime[" + IntToString(0) + "]", lv_dVaPlayer, CatalogFieldValueGet(c_gameCatalogAbil, "Mount", "CastIntroTime[" + IntToString(0) + "]", 0));

    CatalogFieldValueSet(c_gameCatalogAbil, "Mount", "Cost[" + IntToString(0) + "].Cooldown.TimeUse", lv_dVaPlayer, CatalogFieldValueGet(c_gameCatalogAbil, "Mount", "Cost.Cooldown.TimeUse", 0));

    libHDVA_gf_DVaUpdatethePartyFrametoActiveUnit(lv_dVaPlayer);

    AIRemovePlayerUnit(lv_dVaPilotUnit);

    AIAddPlayerUnit(libHDVA_gv_dVaCallMechMechBeingSummoned[lv_dVaPlayer]);

    libUIUI_gv_uIHeroStatusFrames[lv_dVaPlayer].lv_unitCount = 0;

    libUIUI_gf_UIUnitStatusFramesUpdateUnitStatusFramesForUnit(lv_dVaPlayer, libHDVA_gv_dVaCallMechMechBeingSummoned[lv_dVaPlayer]);

    PlayerSetHeroUnit(lv_dVaPlayer, libHDVA_gv_dVaCallMechMechBeingSummoned[lv_dVaPlayer]);

    return true;

}



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

void libHDVA_gt_DVaCallMechMEKAfallCompleted_Init () {

    libHDVA_gt_DVaCallMechMEKAfallCompleted = TriggerCreate("libHDVA_gt_DVaCallMechMEKAfallCompleted_Func");

    TriggerEnable(libHDVA_gt_DVaCallMechMEKAfallCompleted, false);

    TriggerAddEventUnitAbility(libHDVA_gt_DVaCallMechMEKAfallCompleted, null, AbilityCommand("DVaPilotCallMech", 0), c_abilEffectStageFinish, false);

}



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

// Trigger: D.Va - Pilot - Update Energy - Trigger conditions

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

bool libHDVA_gt_DVaPilotUpdateEnergyTriggerconditions_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Actions

    if (!runActions) {

        return true;

    }



    libHDVA_gf_DVaPilotUpdateEnergy(EventPlayer());

    return true;

}



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

void libHDVA_gt_DVaPilotUpdateEnergyTriggerconditions_Init () {

    libHDVA_gt_DVaPilotUpdateEnergyTriggerconditions = TriggerCreate("libHDVA_gt_DVaPilotUpdateEnergyTriggerconditions_Func");

    TriggerEnable(libHDVA_gt_DVaPilotUpdateEnergyTriggerconditions, false);

    TriggerAddEventPlayerEffectUsed(libHDVA_gt_DVaPilotUpdateEnergyTriggerconditions, c_playerAny, "DVaPilotCallMechSetCooldown");

    TriggerAddEventPlayerEffectUsed(libHDVA_gt_DVaPilotUpdateEnergyTriggerconditions, c_playerAny, "DVaPilotWeaponCallMechCooldownReduction");

    TriggerAddEventPlayerEffectUsed(libHDVA_gt_DVaPilotUpdateEnergyTriggerconditions, c_playerAny, "DVaPilotBigShotModifyCallMechCooldown");

}



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

// Trigger: D.Va - Pilot - Update Energy - Mech Self-Destructing

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

bool libHDVA_gt_DVaPilotUpdateEnergyMechSelfDestructing_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Actions

    if (!runActions) {

        return true;

    }



    while ((UnitHasBehavior2(EventUnit(), "DVaPilotDisableCallMech") == true)) {

        Wait(0.125, c_timeGame);

        libHDVA_gf_DVaPilotUpdateEnergy(EventPlayer());

    }

    return true;

}



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

void libHDVA_gt_DVaPilotUpdateEnergyMechSelfDestructing_Init () {

    libHDVA_gt_DVaPilotUpdateEnergyMechSelfDestructing = TriggerCreate("libHDVA_gt_DVaPilotUpdateEnergyMechSelfDestructing_Func");

    TriggerEnable(libHDVA_gt_DVaPilotUpdateEnergyMechSelfDestructing, false);

    TriggerAddEventUnitBehaviorChange(libHDVA_gt_DVaPilotUpdateEnergyMechSelfDestructing, null, "DVaPilotDisableCallMech", c_unitBehaviorChangeCreate);

}



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

// Trigger: Hero - D.Va - Hero Weapon - Force Acquire Target (Taunt)

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

bool libHDVA_gt_HeroDVaHeroWeaponForceAcquireTargetTaunt_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_unittoAttack;

    unit lv_dVaMechUnit;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_dVaMechUnit = EventPlayerEffectUsedUnit(c_effectUnitTarget);



    // Conditions

    if (testConds) {

        if (!((UnitGetType(lv_dVaMechUnit) == "HeroDVaMech"))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    lv_unittoAttack = EventPlayerEffectUsedUnit(c_effectUnitCaster);

    UnitIssueOrder(lv_dVaMechUnit, OrderTargetingUnit(AbilityCommand("DVaAttack", 0), lv_unittoAttack), c_orderQueueReplace);

    return true;

}



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

void libHDVA_gt_HeroDVaHeroWeaponForceAcquireTargetTaunt_Init () {

    libHDVA_gt_HeroDVaHeroWeaponForceAcquireTargetTaunt = TriggerCreate("libHDVA_gt_HeroDVaHeroWeaponForceAcquireTargetTaunt_Func");

    TriggerEnable(libHDVA_gt_HeroDVaHeroWeaponForceAcquireTargetTaunt, false);

    TriggerAddEventPlayerEffectUsed(libHDVA_gt_HeroDVaHeroWeaponForceAcquireTargetTaunt, c_playerAny, "ForceTargetToAttackCasterUnitScriptDummy");

}



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

// Trigger: Hero - D.Va - Hero Weapon Targeting

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

bool libHDVA_gt_HeroDVaHeroWeaponTargeting_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_stage;

    unit lv_dVaUnit;

    unit lv_targetUnit;

    point lv_targetPoint;

    int lv_dVaPlayer;

    abilcmd lv_ability;

    bool lv_hadHoldFire;

    bool lv_hadDisabler;

    bool lv_hadMountedDisabler;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_stage = c_unitAbilStageAll;

    lv_ability = EventUnitAbility();



    // Conditions

    if (testConds) {

        if (!((UnitGetType(EventUnit()) == "HeroDVaMech"))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    lv_dVaUnit = EventUnit();

    lv_dVaPlayer = UnitGetOwner(EventUnit());

    lv_targetUnit = EventUnitTargetUnit();

    lv_stage = EventUnitAbilityStage();

    if ((lv_targetUnit != null) && (UnitFilterMatch(lv_targetUnit, lv_dVaPlayer, UnitFilter(0, 0, (1 << c_targetFilterPlayer) | (1 << c_targetFilterAlly) | (1 << c_targetFilterMissile) | (1 << c_targetFilterItem) | (1 << c_targetFilterCloaked), (1 << (c_targetFilterStasis - 32)) | (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterInvulnerable - 32)))) == true)) {

        if ((lv_stage == c_unitAbilStageExecute)) {

            return true;

        }



        if ((lv_targetUnit == libHDVA_gv_heroDVaCurrentAttackTarget[lv_dVaPlayer]) && (UnitHasBehavior2(libHDVA_gv_heroDVaCurrentAttackTarget[lv_dVaPlayer], "DVaMechWeaponTarget") == true)) {

            return true;

        }



        if ((libHDVA_gv_heroDVaCurrentAttackTarget[lv_dVaPlayer] != null) && (libHDVA_gv_heroDVaCurrentAttackTarget[lv_dVaPlayer] != lv_targetUnit) && (UnitHasBehavior2(libHDVA_gv_heroDVaCurrentAttackTarget[lv_dVaPlayer], "DVaMechWeaponTarget") == true)) {

            UnitCreateEffectUnit(lv_dVaUnit, "DVaMechWeaponRemoveTargetting", libHDVA_gv_heroDVaCurrentAttackTarget[lv_dVaPlayer]);

        }



        UnitCreateEffectUnit(lv_dVaUnit, "DVaMechWeaponClearWeaponTargets", lv_dVaUnit);

        UnitCreateEffectUnit(lv_dVaUnit, "DVaMechWeaponApplyTargetingBehavior", lv_targetUnit);

        libHDVA_gv_heroDVaCurrentAttackTarget[lv_dVaPlayer] = lv_targetUnit;

        UnitBehaviorAdd(lv_dVaUnit, "DVaMechWeaponDisableWeaponScan", lv_dVaUnit, 1);

    }

    else {

        lv_targetPoint = EventUnitTargetPoint();

        if ((lv_targetPoint != null) && (lv_targetPoint != libHDVA_gv_heroDVaAttackTargetPoint[lv_dVaPlayer])) {

            libHDVA_gv_heroDVaAttackTargetPoint[lv_dVaPlayer] = lv_targetPoint;

            if ((libHDVA_gv_heroDVaCurrentAttackTarget[lv_dVaPlayer] != null) && (UnitHasBehavior2(libHDVA_gv_heroDVaCurrentAttackTarget[lv_dVaPlayer], "DVaMechWeaponTarget") == true)) {

                UnitCreateEffectUnit(lv_dVaUnit, "DVaMechWeaponRemoveTargetting", libHDVA_gv_heroDVaCurrentAttackTarget[lv_dVaPlayer]);

            }



            UnitBehaviorRemove(lv_dVaUnit, "DVaMechWeaponDisableWeaponScan", 1);

            libHDVA_gv_heroDVaCurrentAttackTarget[lv_dVaPlayer] = null;

            while ((AbilityCommandGetAbility(OrderGetAbilityCommand(UnitOrder(lv_dVaUnit, 0))) == "attack") && (lv_targetPoint == libHDVA_gv_heroDVaAttackTargetPoint[lv_dVaPlayer])) {

                Wait(0.125, c_timeGame);

            }

            if ((lv_targetPoint == libHDVA_gv_heroDVaAttackTargetPoint[lv_dVaPlayer])) {

                libHDVA_gv_heroDVaAttackTargetPoint[lv_dVaPlayer] = null;

            }



        }



    }

    return true;

}



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

void libHDVA_gt_HeroDVaHeroWeaponTargeting_Init () {

    libHDVA_gt_HeroDVaHeroWeaponTargeting = TriggerCreate("libHDVA_gt_HeroDVaHeroWeaponTargeting_Func");

    TriggerEnable(libHDVA_gt_HeroDVaHeroWeaponTargeting, false);

    TriggerAddEventUnitAbility(libHDVA_gt_HeroDVaHeroWeaponTargeting, null, AbilityCommand("DVaAttack", 0), c_abilEffectStageApproach, false);

    TriggerAddEventUnitAbility(libHDVA_gt_HeroDVaHeroWeaponTargeting, null, AbilityCommand("DVaAttack", 0), c_abilEffectStageCast, false);

    TriggerAddEventUnitAbility(libHDVA_gt_HeroDVaHeroWeaponTargeting, null, AbilityCommand("DVaAttack", 0), c_abilEffectStageChannel, false);

    TriggerAddEventUnitAbility(libHDVA_gt_HeroDVaHeroWeaponTargeting, null, AbilityCommand("DVaAttack", 0), c_abilEffectStageWait, false);

    TriggerAddEventUnitAbility(libHDVA_gt_HeroDVaHeroWeaponTargeting, null, AbilityCommand("DVaAttack", 0), c_abilEffectStageMove, false);

    TriggerAddEventUnitAbility(libHDVA_gt_HeroDVaHeroWeaponTargeting, null, AbilityCommand("DVaAttack", 0), c_unitAbilStageExecute, false);

}



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

// Trigger: Hero - D.Va - Target Acquired

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

bool libHDVA_gt_HeroDVaTargetAcquired_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_targetUnit;

    int lv_dVaPlayer;

    unit lv_dVa;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_targetUnit = EventPlayerEffectUsedUnit(c_effectUnitTarget);

    lv_dVaPlayer = UnitGetOwner(EventPlayerEffectUsedUnit(c_effectUnitCaster));



    // Conditions

    if (testConds) {

        if (!((lv_targetUnit != libHDVA_gv_heroDVaCurrentAttackTarget[lv_dVaPlayer]))) {

            return false;

        }



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

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    lv_dVa = EventPlayerEffectUsedUnit(c_effectUnitCaster);

    if ((libHDVA_gv_heroDVaCurrentAttackTarget[lv_dVaPlayer] != null) && (libHDVA_gv_heroDVaCurrentAttackTarget[lv_dVaPlayer] != lv_targetUnit) && (UnitHasBehavior2(libHDVA_gv_heroDVaCurrentAttackTarget[lv_dVaPlayer], "DVaMechWeaponTarget") == true)) {

        UnitCreateEffectUnit(lv_dVa, "DVaMechWeaponRemoveTargetting", libHDVA_gv_heroDVaCurrentAttackTarget[lv_dVaPlayer]);

    }



    UnitCreateEffectUnit(lv_dVa, "DVaMechWeaponClearWeaponTargets", lv_dVa);

    UnitCreateEffectUnit(lv_dVa, "DVaMechWeaponApplyTargetingBehavior", lv_targetUnit);

    libHDVA_gv_heroDVaCurrentAttackTarget[lv_dVaPlayer] = lv_targetUnit;

    UnitBehaviorAdd(lv_dVa, "DVaMechWeaponDisableWeaponScan", lv_dVa, 1);

    return true;

}



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

void libHDVA_gt_HeroDVaTargetAcquired_Init () {

    libHDVA_gt_HeroDVaTargetAcquired = TriggerCreate("libHDVA_gt_HeroDVaTargetAcquired_Func");

    TriggerEnable(libHDVA_gt_HeroDVaTargetAcquired, false);

    TriggerAddEventPlayerEffectUsed(libHDVA_gt_HeroDVaTargetAcquired, c_playerAny, "DVaMechWeaponNewTargetImpactSet");

}



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

// Trigger: Hero - D.Va - Hold Fire Controller - Hold Fire Apply

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

bool libHDVA_gt_HeroDVaHoldFireControllerHoldFireApply_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_triggeringUnit;

    int lv_dVaPlayer;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_triggeringUnit = EventUnit();



    // Conditions

    if (testConds) {

        if (!((UnitGetType(lv_triggeringUnit) == "HeroDVaMech"))) {

            return false;

        }



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

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    UnitBehaviorRemove(lv_triggeringUnit, "DVaMechArtWeaponCasterSoundDummyLoop", 1);

    lv_dVaPlayer = UnitGetOwner(lv_triggeringUnit);

    UnitCreateEffectUnit(lv_triggeringUnit, "DVaMechWeaponRemoveTargetting", libHDVA_gv_heroDVaCurrentAttackTarget[lv_dVaPlayer]);

    libHDVA_gv_heroDVaCurrentAttackTarget[lv_dVaPlayer] = null;

    UnitCreateEffectUnit(lv_triggeringUnit, "DVaMechWeaponClearWeaponTargets", lv_triggeringUnit);

    UnitBehaviorAdd(lv_triggeringUnit, "DVaMechWeaponDisableWeaponScan", lv_triggeringUnit, 1);

    return true;

}



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

void libHDVA_gt_HeroDVaHoldFireControllerHoldFireApply_Init () {

    libHDVA_gt_HeroDVaHoldFireControllerHoldFireApply = TriggerCreate("libHDVA_gt_HeroDVaHoldFireControllerHoldFireApply_Func");

    TriggerEnable(libHDVA_gt_HeroDVaHoldFireControllerHoldFireApply, false);

    TriggerAddEventUnitBehaviorChangeFromCategory(libHDVA_gt_HeroDVaHoldFireControllerHoldFireApply, null, c_behaviorCategoryFear, c_unitBehaviorChangeCreate);

    TriggerAddEventUnitOrder(libHDVA_gt_HeroDVaHoldFireControllerHoldFireApply, null, AbilityCommand("HoldFire", 1));

    TriggerAddEventUnitOrder(libHDVA_gt_HeroDVaHoldFireControllerHoldFireApply, null, AbilityCommand("HoldFire", 3));

    TriggerAddEventUnitOrder(libHDVA_gt_HeroDVaHoldFireControllerHoldFireApply, null, AbilityCommand("HoldFire", 4));

}



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

// Trigger: Hero - D.Va - Hold Fire Controller - Hold Fire Remove

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

bool libHDVA_gt_HeroDVaHoldFireControllerHoldFireRemove_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_triggeringUnit;

    int lv_dVaPlayer;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_triggeringUnit = EventUnit();



    // Conditions

    if (testConds) {

        if (!((UnitGetType(lv_triggeringUnit) == "HeroDVaMech"))) {

            return false;

        }



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

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    lv_dVaPlayer = UnitGetOwner(lv_triggeringUnit);

    UnitCreateEffectUnit(lv_triggeringUnit, "DVaMechWeaponRemoveTargetting", libHDVA_gv_heroDVaCurrentAttackTarget[lv_dVaPlayer]);

    libHDVA_gv_heroDVaCurrentAttackTarget[lv_dVaPlayer] = null;

    UnitCreateEffectUnit(lv_triggeringUnit, "DVaMechWeaponClearWeaponTargets", lv_triggeringUnit);

    UnitBehaviorAdd(lv_triggeringUnit, "DVaMechWeaponDisableWeaponScan", lv_triggeringUnit, 1);

    return true;

}



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

void libHDVA_gt_HeroDVaHoldFireControllerHoldFireRemove_Init () {

    libHDVA_gt_HeroDVaHoldFireControllerHoldFireRemove = TriggerCreate("libHDVA_gt_HeroDVaHoldFireControllerHoldFireRemove_Func");

    TriggerEnable(libHDVA_gt_HeroDVaHoldFireControllerHoldFireRemove, false);

    TriggerAddEventUnitAbility(libHDVA_gt_HeroDVaHoldFireControllerHoldFireRemove, null, AbilityCommand("HoldFire", 1), c_unitAbilStageCancel, false);

    TriggerAddEventUnitAbility(libHDVA_gt_HeroDVaHoldFireControllerHoldFireRemove, null, AbilityCommand("HoldFire", 1), c_unitAbilStageComplete, false);

    TriggerAddEventUnitAbility(libHDVA_gt_HeroDVaHoldFireControllerHoldFireRemove, null, AbilityCommand("HoldFire", 3), c_unitAbilStageCancel, false);

    TriggerAddEventUnitAbility(libHDVA_gt_HeroDVaHoldFireControllerHoldFireRemove, null, AbilityCommand("HoldFire", 3), c_unitAbilStageComplete, false);

    TriggerAddEventUnitAbility(libHDVA_gt_HeroDVaHoldFireControllerHoldFireRemove, null, AbilityCommand("HoldFire", 4), c_unitAbilStageCancel, false);

    TriggerAddEventUnitAbility(libHDVA_gt_HeroDVaHoldFireControllerHoldFireRemove, null, AbilityCommand("HoldFire", 4), c_unitAbilStageComplete, false);

    TriggerAddEventUnitBehaviorChangeFromCategory(libHDVA_gt_HeroDVaHoldFireControllerHoldFireRemove, null, c_behaviorCategoryFear, c_unitBehaviorChangeDestroy);

}



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

// Trigger: Hero - D.Va - Remove weapon target from Data

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

bool libHDVA_gt_HeroDVaRemoveweapontargetfromData_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_dVaMech;

    int lv_dVaPlayer;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_dVaMech = EventPlayerEffectUsedUnit(c_effectUnitCaster);



    // Conditions

    if (testConds) {

        if (!((UnitGetType(lv_dVaMech) == "HeroDVaMech"))) {

            return false;

        }



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

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    UnitBehaviorRemove(lv_dVaMech, "DVaMechArtWeaponCasterSoundDummyLoop", 1);

    lv_dVaPlayer = UnitGetOwner(lv_dVaMech);

    UnitCreateEffectUnit(lv_dVaMech, "DVaMechWeaponRemoveTargetting", libHDVA_gv_heroDVaCurrentAttackTarget[UnitGetOwner(lv_dVaMech)]);

    libHDVA_gv_heroDVaCurrentAttackTarget[lv_dVaPlayer] = null;

    UnitCreateEffectUnit(lv_dVaMech, "DVaMechWeaponClearWeaponTargets", lv_dVaMech);

    UnitBehaviorAdd(lv_dVaMech, "DVaMechWeaponDisableWeaponScan", lv_dVaMech, 1);

    return true;

}



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

void libHDVA_gt_HeroDVaRemoveweapontargetfromData_Init () {

    libHDVA_gt_HeroDVaRemoveweapontargetfromData = TriggerCreate("libHDVA_gt_HeroDVaRemoveweapontargetfromData_Func");

    TriggerEnable(libHDVA_gt_HeroDVaRemoveweapontargetfromData, false);

    TriggerAddEventPlayerEffectUsed(libHDVA_gt_HeroDVaRemoveweapontargetfromData, c_playerAny, "DVaMechWeaponRemoveScriptTargetDummy");

}



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

// Trigger: D.Va - Liquid Cooling Cooldown Sync

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

bool libHDVA_gt_DVaLiquidCoolingCooldownSync_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    return true;

}



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

void libHDVA_gt_DVaLiquidCoolingCooldownSync_Init () {

    libHDVA_gt_DVaLiquidCoolingCooldownSync = TriggerCreate("libHDVA_gt_DVaLiquidCoolingCooldownSync_Func");

}



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

// Trigger: D.Va - Liquid Cooling Duration Fix

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

bool libHDVA_gt_DVaLiquidCoolingDurationFix_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Actions

    if (!runActions) {

        return true;

    }



    CatalogFieldValueSetFixed(c_gameCatalogBehavior, "HealingFountainCooldown", "Duration", EventPlayerEffectUsedUnitOwner(c_effectPlayerCaster), CatalogFieldValueGetAsFixed(c_gameCatalogBehavior, "HealingFountainCooldown", "Duration", c_playerAny));

    return true;

}



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

void libHDVA_gt_DVaLiquidCoolingDurationFix_Init () {

    libHDVA_gt_DVaLiquidCoolingDurationFix = TriggerCreate("libHDVA_gt_DVaLiquidCoolingDurationFix_Func");

    TriggerEnable(libHDVA_gt_DVaLiquidCoolingDurationFix, false);

    TriggerAddEventPlayerEffectUsed(libHDVA_gt_DVaLiquidCoolingDurationFix, c_playerAny, "DVaLiquidCoolingResetPlayer");

}



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

// Trigger: Hero - D.Va - Fusion Generator FCT Increment

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

bool libHDVA_gt_HeroDVaFusionGeneratorFCTIncrement_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_player;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_player = UnitGetOwner(EventPlayerEffectUsedUnit(c_effectUnitCaster));



    // Conditions

    if (testConds) {

        if (!((libHDVA_gv_heroDVaFusionGeneratorFCTNumbers[lv_player] < CatalogFieldValueGetAsInt(c_gameCatalogBehavior, "DVaDefenseMatrixFusionGeneratorCounterToken", "Max", 0)))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libHDVA_gv_heroDVaFusionGeneratorFCTNumbers[lv_player] += 1;

    return true;

}



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

void libHDVA_gt_HeroDVaFusionGeneratorFCTIncrement_Init () {

    libHDVA_gt_HeroDVaFusionGeneratorFCTIncrement = TriggerCreate("libHDVA_gt_HeroDVaFusionGeneratorFCTIncrement_Func");

    TriggerEnable(libHDVA_gt_HeroDVaFusionGeneratorFCTIncrement, false);

    TriggerAddEventPlayerEffectUsed(libHDVA_gt_HeroDVaFusionGeneratorFCTIncrement, c_playerAny, "DVaMechDefenseMatrixFusionGeneratorIncrementCounterToken");

}



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

// Trigger: Hero - D.Va - Fusion Generator FCT Final

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

bool libHDVA_gt_HeroDVaFusionGeneratorFCTFinal_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_player;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_player = UnitGetOwner(EventPlayerEffectUsedUnit(c_effectUnitCaster));



    // Actions

    if (!runActions) {

        return true;

    }



    Wait(0.1875, c_timeGame);

    TextExpressionSetToken("Param/Expression/lib_HDVA_4C7FAA27", "A", FixedToText(libHDVA_gv_heroDVaFusionGeneratorFCTNumbers[lv_player], 0));

    FloatingCombatElementCreateTextAtUnit(PlayerGroupSingle(lv_player), "FloatingCombatElements/FloatingCombatAmountReadable", "", EventPlayerEffectUsedUnit(c_effectUnitCaster), TextExpressionAssemble("Param/Expression/lib_HDVA_4C7FAA27"), libNtve_gv_FloatingCombatTextAutoRandomSeed);

    libHDVA_gv_heroDVaFusionGeneratorFCTNumbers[lv_player] = 0;

    return true;

}



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

void libHDVA_gt_HeroDVaFusionGeneratorFCTFinal_Init () {

    libHDVA_gt_HeroDVaFusionGeneratorFCTFinal = TriggerCreate("libHDVA_gt_HeroDVaFusionGeneratorFCTFinal_Func");

    TriggerEnable(libHDVA_gt_HeroDVaFusionGeneratorFCTFinal, false);

    TriggerAddEventPlayerEffectUsed(libHDVA_gt_HeroDVaFusionGeneratorFCTFinal, c_playerAny, "DVaMechDefenseMatrixFusionGeneratorRemoveCounterToken");

}



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

// Trigger: D.Va - Ablative Armor Healing Conversion

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

bool libHDVA_gt_DVaAblativeArmorHealingConversion_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_dVaMech;

    int lv_dVaPlayer;

    fixed lv_incomingDamage;

    fixed lv_damageMod;

    fixed lv_tokenCount;

    int lv_duration;

    int lv_durationIterator;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_dVaMech = EventUnit();

    lv_dVaPlayer = UnitGetOwner(lv_dVaMech);

    lv_incomingDamage = (EventUnitDamageAmount()+EventUnitDamageBehaviorShield());

    lv_damageMod = CatalogFieldValueGetAsFixed(c_gameCatalogBehavior, "DVaAblativeArmorDamageModDummy", "DamageResponse.ModifyFraction", 0);

    lv_tokenCount = (lv_incomingDamage * lv_damageMod);

    lv_duration = FixedToInt(CatalogFieldValueGetAsFixed(c_gameCatalogBehavior, "DVaAblativeArmorHealingBuff", "Duration", 0));



    // Conditions

    if (testConds) {

        if (!((UnitBehaviorCount(lv_dVaMech, "DVaMechSelfDestructMechDetonationCountdown") == 0))) {

            return false;

        }



        if (!((PlayerHasTalent(lv_dVaPlayer, "DVaMechAblativeArmor") == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    lv_durationIterator = lv_duration;

    libGame_gf_ModifyTokenCount(FixedToInt(lv_tokenCount), "DVaAblativeArmorTokenCounter", lv_dVaMech);

    UnitCreateEffectUnit(lv_dVaMech, "DVaAblativeArmorHealingBuffSwitch", lv_dVaMech);

    Wait(1.0, c_timeGame);

    while ((UnitIsAlive(lv_dVaMech) == true) && (UnitBehaviorCount(lv_dVaMech, "DVaMechSelfDestructMechDetonationCountdown") == 0) && (lv_durationIterator > 0)) {

        if ((UnitHasBehaviorWithCategoryFlag(lv_dVaMech, c_behaviorCategoryTimeStop) == true)) {

            while (!((UnitHasBehaviorWithCategoryFlag(lv_dVaMech, c_behaviorCategoryTimeStop) == false))) {

                Wait(0.0625, c_timeGame);

            }

        }



        lv_durationIterator -= 1;

        Wait(1.0, c_timeGame);

    }

    libGame_gf_ModifyTokenCount(FixedToInt((-1.0 * FixedToInt(lv_tokenCount))), "DVaAblativeArmorTokenCounter", lv_dVaMech);

    return true;

}



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

void libHDVA_gt_DVaAblativeArmorHealingConversion_Init () {

    libHDVA_gt_DVaAblativeArmorHealingConversion = TriggerCreate("libHDVA_gt_DVaAblativeArmorHealingConversion_Func");

    TriggerEnable(libHDVA_gt_DVaAblativeArmorHealingConversion, false);

    TriggerAddDamageEvent(libHDVA_gt_DVaAblativeArmorHealingConversion, null, "HeroDVaMech", c_unitDamageTypeAbility, c_unitDamageNonFatal, null);

}



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

// Trigger: D.Va - Talent Behavior Acquired While Cargo Forwarding

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

bool libHDVA_gt_DVaTalentBehaviorAcquiredWhileCargoForwarding_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_dVaPilot;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_dVaPilot = EventUnit();



    // Conditions

    if (testConds) {

        if (!((libNtve_gf_UnitIsInsideTransport(lv_dVaPilot) == true))) {

            return false;

        }



        if (!((UnitGetType(lv_dVaPilot) == "HeroDVaPilot"))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    UnitBehaviorAdd(UnitTransport(lv_dVaPilot), EventUnitBehavior(), lv_dVaPilot, 1);

    return true;

}



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

void libHDVA_gt_DVaTalentBehaviorAcquiredWhileCargoForwarding_Init () {

    libHDVA_gt_DVaTalentBehaviorAcquiredWhileCargoForwarding = TriggerCreate("libHDVA_gt_DVaTalentBehaviorAcquiredWhileCargoForwarding_Func");

    TriggerEnable(libHDVA_gt_DVaTalentBehaviorAcquiredWhileCargoForwarding, false);

    TriggerAddEventUnitBehaviorChange(libHDVA_gt_DVaTalentBehaviorAcquiredWhileCargoForwarding, null, "Ultimate1Unlocked", c_unitBehaviorChangeCreate);

    TriggerAddEventUnitBehaviorChange(libHDVA_gt_DVaTalentBehaviorAcquiredWhileCargoForwarding, null, "Ultimate2Unlocked", c_unitBehaviorChangeCreate);

    TriggerAddEventUnitBehaviorChange(libHDVA_gt_DVaTalentBehaviorAcquiredWhileCargoForwarding, null, "DVaMechProMovesDamageResponseCarry", c_unitBehaviorChangeCreate);

    TriggerAddEventUnitBehaviorChange(libHDVA_gt_DVaTalentBehaviorAcquiredWhileCargoForwarding, null, "DVaMechEmergencyShieldingFatalResponseCarry", c_unitBehaviorChangeCreate);

    TriggerAddEventUnitBehaviorChange(libHDVA_gt_DVaTalentBehaviorAcquiredWhileCargoForwarding, null, "DVaMechAblativeArmorDamageResponseCarry", c_unitBehaviorChangeCreate);

    TriggerAddEventUnitBehaviorChange(libHDVA_gt_DVaTalentBehaviorAcquiredWhileCargoForwarding, null, "DVaFullMetalCarry", c_unitBehaviorChangeCreate);

    TriggerAddEventUnitBehaviorChange(libHDVA_gt_DVaTalentBehaviorAcquiredWhileCargoForwarding, null, "DVaLiquidCoolingAbility", c_unitBehaviorChangeCreate);

}



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

// Trigger: Hero - D.Va - Actor Sound Swaps

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

bool libHDVA_gt_HeroDVaActorSoundSwaps_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_dVa;

    int lv_dVaPlayer;



    // Automatic Variable Declarations

    // Variable Initialization



    // Actions

    if (!runActions) {

        return true;

    }



    lv_dVa = EventUnit();

    lv_dVaPlayer = UnitGetOwner(lv_dVa);

    libGame_gv_players[lv_dVaPlayer].lv_vOPissedSoundIndex = 0;

    if ((UnitHasBehavior2(lv_dVa, "DVaPilotInsideMech") == true)) {

        if ((libGame_gv_players[lv_dVaPlayer].lv_heroUnit == lv_dVa)) {

            libGame_gv_players[lv_dVaPlayer].lv_vOSoundSuffix = "";

        }



    }

    else {

        if ((UnitHasBehavior2(lv_dVa, "UltimateEvolutionBuff") == true)) {

            libNtve_gf_SendActorMessageToUnit(lv_dVa, "SetSoundSuffix _Evo_P");

        }



        if ((libGame_gv_players[lv_dVaPlayer].lv_heroUnit == lv_dVa)) {

            libGame_gv_players[lv_dVaPlayer].lv_vOSoundSuffix = "_P";

        }



    }

    return true;

}



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

void libHDVA_gt_HeroDVaActorSoundSwaps_Init () {

    libHDVA_gt_HeroDVaActorSoundSwaps = TriggerCreate("libHDVA_gt_HeroDVaActorSoundSwaps_Func");

    TriggerEnable(libHDVA_gt_HeroDVaActorSoundSwaps, false);

    TriggerAddEventUnitBehaviorChange(libHDVA_gt_HeroDVaActorSoundSwaps, null, "DVaPilotInsideMech", c_unitBehaviorChangeActivate);

    TriggerAddEventUnitBehaviorChange(libHDVA_gt_HeroDVaActorSoundSwaps, null, "DVaPilotInsideMech", c_unitBehaviorChangeDeactivate);

}



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

// Trigger: DEBUG - Refresh Cooldowns (-cdr)

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

bool libHDVA_gt_DEBUGRefreshCooldownscdr_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_dVaHeroUnit;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_dVaHeroUnit = libGame_gv_players[EventPlayer()].lv_heroUnit;



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((UnitGetType(lv_dVaHeroUnit) == "HeroDVaPilot"))) {

            return false;

        }



        if (!((libNtve_gf_UnitIsInsideTransport(lv_dVaHeroUnit) == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libGame_gf_HeroRefreshCooldowns(EventPlayer(), true);

    return true;

}



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

void libHDVA_gt_DEBUGRefreshCooldownscdr_Init () {

    libHDVA_gt_DEBUGRefreshCooldownscdr = TriggerCreate("libHDVA_gt_DEBUGRefreshCooldownscdr_Func");

    TriggerAddEventChatMessage(libHDVA_gt_DEBUGRefreshCooldownscdr, c_playerAny, "-cdr", true);

    TriggerAddEventChatMessage(libHDVA_gt_DEBUGRefreshCooldownscdr, c_playerAny, "cdr", true);

}



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

// Trigger: DEBUG - DVa XP Equalizer

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

bool libHDVA_gt_DEBUGDVaXPEqualizer_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_dVaMech;

    unit lv_dVaPilot;

    fixed lv_mechXP;

    fixed lv_pilotXP;



    // Automatic Variable Declarations

    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }



        if (!((UnitHasBehavior2(EventUnit(), "UltimateEvolutionBuff") == false))) {

            return false;

        }



        if (!((UnitHasBehavior2(EventUnit(), "DVaMechCallMechMechHologramInvulnerable") == false))) {

            return false;

        }



        if (!((UnitGetType(EventUnit()) == "HeroDVaMech"))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    lv_dVaMech = EventUnit();

    lv_dVaPilot = UnitCargo(lv_dVaMech, 1);

    lv_mechXP = UnitXPTotal(lv_dVaMech);

    lv_pilotXP = UnitXPTotal(lv_dVaPilot);

    if ((lv_mechXP > lv_pilotXP)) {

        UnitXPAddXP(lv_dVaPilot, null, EventUnitXPDelta());

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_HDVA_B161F94A"), true);

    }



    return true;

}



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

void libHDVA_gt_DEBUGDVaXPEqualizer_Init () {

    libHDVA_gt_DEBUGDVaXPEqualizer = TriggerCreate("libHDVA_gt_DEBUGDVaXPEqualizer_Func");

    TriggerAddEventUnitGainExperience(libHDVA_gt_DEBUGDVaXPEqualizer, null);

}



void libHDVA_InitTriggers () {

    libHDVA_gt_ModInitialization_Init();

    libHDVA_gt_HeroDVaManualSpawn_Init();

    libHDVA_gt_DVaRespawn_Init();

    libHDVA_gt_DVaRespawnAurielLightSpeedSpecialCase_Init();

    libHDVA_gt_DVaMoonwellRedistribution_Init();

    libHDVA_gt_DVaCargoUnloadedSelectionControl_Init();

    libHDVA_gt_DVaAbathurCreatesaDVaClone_Init();

    libHDVA_gt_DVaAbathurClonedMechEnds_Init();

    libHDVA_gt_HeroDVaPilotEjectedMoveCommandForwarding_Init();

    libHDVA_gt_HeroDVaMechDiesviaFatalDamage_Init();

    libHDVA_gt_HeroDVaMicroMissilesActive_Init();

    libHDVA_gt_DVaBoostersEnemyHallofStorms_Init();

    libHDVA_gt_DVaDefenseMatrixTracker_Init();

    libHDVA_gt_DVaDefenseMatrixTrackerReportandReset_Init();

    libHDVA_gt_DVaDamageTakenSelfDestructCharge_Init();

    libHDVA_gt_DVaCallMech_Init();

    libHDVA_gt_DVaCallMechInterrupted_Init();

    libHDVA_gt_DVaCallMechMEKAfallCompleted_Init();

    libHDVA_gt_DVaPilotUpdateEnergyTriggerconditions_Init();

    libHDVA_gt_DVaPilotUpdateEnergyMechSelfDestructing_Init();

    libHDVA_gt_HeroDVaHeroWeaponForceAcquireTargetTaunt_Init();

    libHDVA_gt_HeroDVaHeroWeaponTargeting_Init();

    libHDVA_gt_HeroDVaTargetAcquired_Init();

    libHDVA_gt_HeroDVaHoldFireControllerHoldFireApply_Init();

    libHDVA_gt_HeroDVaHoldFireControllerHoldFireRemove_Init();

    libHDVA_gt_HeroDVaRemoveweapontargetfromData_Init();

    libHDVA_gt_DVaLiquidCoolingCooldownSync_Init();

    libHDVA_gt_DVaLiquidCoolingDurationFix_Init();

    libHDVA_gt_HeroDVaFusionGeneratorFCTIncrement_Init();

    libHDVA_gt_HeroDVaFusionGeneratorFCTFinal_Init();

    libHDVA_gt_DVaAblativeArmorHealingConversion_Init();

    libHDVA_gt_DVaTalentBehaviorAcquiredWhileCargoForwarding_Init();

    libHDVA_gt_HeroDVaActorSoundSwaps_Init();

    libHDVA_gt_DEBUGRefreshCooldownscdr_Init();

    libHDVA_gt_DEBUGDVaXPEqualizer_Init();

}



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

// Library Initialization

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

bool libHDVA_InitLib_completed = false;



void libHDVA_InitLib () {

    if (libHDVA_InitLib_completed) {

        return;

    }



    libHDVA_InitLib_completed = true;



    libHDVA_InitLibraries();

    libHDVA_InitVariables();

    libHDVA_InitTriggers();

}