PTR build 2.57.1.98674_ptr. Go to the live site.

mods/heromods/dva.stormmod/base.stormdata/libhdva.galaxy

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