PTR build 2.57.1.98674_ptr. Go to the live site.

mods/heromods/tracer.stormmod/base.stormdata/libtrac.galaxy

libtrac.galaxy
include "TriggerLibs/NativeLib"
include "TriggerLibs/HeroesLib"
include "TriggerLibs/GameLib"
include "TriggerLibs/UILib"
include "TriggerLibs/SoundLib"
include "TriggerLibs/GameDataHelperLib"

include "LibTrac_h"

//--------------------------------------------------------------------------------------------------
// Library: Tracer
//--------------------------------------------------------------------------------------------------
// External Library Initialization
void libTrac_InitLibraries () {
    libNtve_InitVariables();
    libCore_InitVariables();
    libGame_InitVariables();
    libUIUI_InitVariables();
    libSond_InitVariables();
    libGDHL_InitVariables();
}

// Variable Initialization
bool libTrac_InitVariables_completed = false;

void libTrac_InitVariables () {
    int init_i;
    int init_j;

    if (libTrac_InitVariables_completed) {
        return;
    }

    libTrac_InitVariables_completed = true;

    libTrac_gv_tracerUI.lv_tracerPulseBombFrame = c_invalidDialogControlId;
    libTrac_gv_tracerUI.lv_tracerStuckTextImage = c_invalidDialogControlId;
    for (init_i = 0; init_i <= libCore_gv_bALMaxPlayers; init_i += 1) {
        for (init_j = 0; init_j <= libTrac_gv_tracerRecallTrackCountMax; init_j += 1) {
            libTrac_gv_tracerRecallRecordVariable[init_i][init_j].lv_tempTextTag = c_textTagNone;
        }
    }
}

// Functions
void libTrac_gf_HeroTracerIncrementHeroCountFunction () {
    // Automatic Variable Declarations
    // Implementation
    libTrac_gv_heroTracerTriggerRegistrationVariable += 1;
    if ((libTrac_gv_heroTracerTriggerRegistrationVariable == 1)) {
        TriggerEnable(libTrac_gt_HeroTracerPulseBombStuckOverlayOn, true);
        TriggerEnable(libTrac_gt_HeroTracerPulseBombStuckOverlayOff, true);
        TriggerEnable(libTrac_gt_HeroTracerCustomKillVO, true);
        TriggerEnable(libTrac_gt_HeroTracerReloadRestoreAmmoOnHearthMount, true);
        TriggerEnable(libTrac_gt_HeroTracerUntouchableProc, true);
        TriggerEnable(libTrac_gt_HeroTracerSpatialEchoProc, true);
        TriggerEnable(libTrac_gt_HeroTracerPulseBombSetFacing, true);
        TriggerEnable(libTrac_gt_HeroTracerHeroWeaponApplyTargetingUnit, true);
        TriggerEnable(libTrac_gt_HeroTracerTargetAcquired, true);
        TriggerEnable(libTrac_gt_HeroTracerForceAcquireTargetTaunt, true);
        TriggerEnable(libTrac_gt_HeroTracerHoldFire, true);
        TriggerEnable(libTrac_gt_HeroTracerUpdateRecallRecord, true);
        TriggerEnable(libTrac_gt_HeroTracerUpdateRecallonTracerHearth, true);
        TriggerEnable(libTrac_gt_HeroTracerRecallCast, true);
        TriggerEnable(libTrac_gt_HeroTracerRecallCameraLock, true);
        TriggerEnable(libTrac_gt_HeroTracerRecallDebugMode, true);
        TriggerEnable(libTrac_gt_HeroTracerUltimateEvolutionRecall, true);
        TriggerEnable(libTrac_gt_HeroTracerMeleeSetFacing, true);
        TriggerEnable(libTrac_gt_HeroTracerUpdateRecallPointsonRevive, true);
        TriggerEnable(libTrac_gt_HeroTracerClearTargetViaEffect, true);
    }

}

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

    if ((libTrac_gv_heroTracerTriggerRegistrationVariable == 0)) {
        TriggerEnable(libTrac_gt_HeroTracerReloadRestoreAmmoOnHearthMount, false);
        TriggerEnable(libTrac_gt_HeroTracerUntouchableProc, false);
        TriggerEnable(libTrac_gt_HeroTracerSpatialEchoProc, false);
        TriggerEnable(libTrac_gt_HeroTracerPulseBombSetFacing, false);
        TriggerEnable(libTrac_gt_HeroTracerPulseBombStuckOverlayOn, false);
        TriggerEnable(libTrac_gt_HeroTracerPulseBombStuckOverlayOff, false);
        TriggerEnable(libTrac_gt_HeroTracerHeroWeaponApplyTargetingUnit, false);
        TriggerEnable(libTrac_gt_HeroTracerTargetAcquired, false);
        TriggerEnable(libTrac_gt_HeroTracerForceAcquireTargetTaunt, false);
        TriggerEnable(libTrac_gt_HeroTracerHoldFire, false);
        TriggerEnable(libTrac_gt_HeroTracerUpdateRecallRecord, false);
        TriggerEnable(libTrac_gt_HeroTracerUpdateRecallonTracerHearth, false);
        TriggerEnable(libTrac_gt_HeroTracerRecallCast, false);
        TriggerEnable(libTrac_gt_HeroTracerRecallCameraLock, false);
        TriggerEnable(libTrac_gt_HeroTracerRecallDebugMode, false);
        TriggerEnable(libTrac_gt_HeroTracerUltimateEvolutionRecall, false);
        TriggerEnable(libTrac_gt_HeroTracerMeleeSetFacing, false);
        TriggerEnable(libTrac_gt_HeroTracerCustomKillVO, false);
        TriggerEnable(libTrac_gt_HeroTracerUpdateRecallPointsonRevive, false);
        TriggerEnable(libTrac_gt_HeroTracerClearTargetViaEffect, false);
    }

}

int libTrac_gf_HeroTracerRecallDetermineIndex (int lp_player) {
    // Variable Declarations
    int lv_index;

    // Automatic Variable Declarations
    const int autoC7744398_ae = 1;
    const int autoC7744398_ai = -1;
    const int autoB60BB15E_ae = 1;
    const int autoB60BB15E_ai = -1;

    // Variable Initialization

    // Implementation
    if ((PlayerHasTalent(lp_player, "TracerTelefrag") == true)) {
        lv_index = (libTrac_gv_tracerRecallTrackCountMax - 0);
        for ( ; ( (autoC7744398_ai >= 0 && lv_index <= autoC7744398_ae) || (autoC7744398_ai < 0 && lv_index >= autoC7744398_ae) ) ; lv_index += autoC7744398_ai ) {
            if (((libTrac_gv_tracerRecallRecordVariable[lp_player][lv_index].lv_position != null) && (PointPathingPassable(libTrac_gv_tracerRecallRecordVariable[lp_player][lv_index].lv_position) == true))) {
                return lv_index;
            }

        }
    }
    else {
        lv_index = (libTrac_gv_tracerRecallTrackCountMax - 0);
        for ( ; ( (autoB60BB15E_ai >= 0 && lv_index <= autoB60BB15E_ae) || (autoB60BB15E_ai < 0 && lv_index >= autoB60BB15E_ae) ) ; lv_index += autoB60BB15E_ai ) {
            if (((libTrac_gv_tracerRecallRecordVariable[lp_player][lv_index].lv_position != null) && (PointPathingPassable(libTrac_gv_tracerRecallRecordVariable[lp_player][lv_index].lv_position) == true))) {
                return lv_index;
            }

        }
    }
    return -1;
}

void libTrac_gf_HeroTracerResetAllRecallPointstoCurrentPosition (int lp_player, unit lp_tracer) {
    // Variable Declarations
    int lv_itRecallCount;

    // Automatic Variable Declarations
    const int autoD98AA8CD_ae = 1;
    const int autoD98AA8CD_ai = -1;

    // Variable Initialization

    // Implementation
    lv_itRecallCount = libTrac_gv_tracerRecallTrackCountMax;
    for ( ; ( (autoD98AA8CD_ai >= 0 && lv_itRecallCount <= autoD98AA8CD_ae) || (autoD98AA8CD_ai < 0 && lv_itRecallCount >= autoD98AA8CD_ae) ) ; lv_itRecallCount += autoD98AA8CD_ai ) {
        libTrac_gv_tracerRecallRecordVariable[lp_player][lv_itRecallCount].lv_position = UnitGetPosition(lp_tracer);
    }
}

void libTrac_gf_HeroTracerCreateorUpdateAIRecallTrackerUnit (unit lp_tracerUnit) {
    // Variable Declarations
    int lv_itIndex;
    int lv_tracerPlayer;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_tracerPlayer = UnitGetOwner(lp_tracerUnit);

    // Implementation
    if ((UnitIsAlive(lp_tracerUnit) == true)) {
        lv_itIndex = libTrac_gf_HeroTracerRecallDetermineIndex(lv_tracerPlayer);
        if ((lv_itIndex >= 0)) {
            if ((UnitIsValid(libTrac_gv_tracerRecallUnit[lv_tracerPlayer]) == false)) {
                libNtve_gf_CreateUnitsWithDefaultFacing(1, "TracerRecallUnitAITracking", 0, lv_tracerPlayer, libTrac_gv_tracerRecallRecordVariable[lv_tracerPlayer][lv_itIndex].lv_position, lp_tracerUnit);
                UnitSetPropertyFixed(libTrac_gv_tracerRecallUnit[lv_tracerPlayer], c_unitPropEnergyMax, libTrac_gv_tracerRecallRecordVariable[lv_tracerPlayer][lv_itIndex].lv_health);
                UnitCreateEffectUnit(lp_tracerUnit, "TracerRecallUnitAddToTrackingList", UnitLastCreated());
                libTrac_gv_tracerRecallUnit[lv_tracerPlayer] = UnitLastCreated();
            }
            else {
                UnitSetPosition(libTrac_gv_tracerRecallUnit[lv_tracerPlayer], libTrac_gv_tracerRecallRecordVariable[lv_tracerPlayer][lv_itIndex].lv_position, false);
                UnitSetPropertyFixed(libTrac_gv_tracerRecallUnit[lv_tracerPlayer], c_unitPropEnergyMax, libTrac_gv_tracerRecallRecordVariable[lv_tracerPlayer][lv_itIndex].lv_health);
            }
        }

    }
    else {
        if ((UnitIsValid(libTrac_gv_tracerRecallUnit[lv_tracerPlayer]) == true)) {
            UnitRemove(libTrac_gv_tracerRecallUnit[lv_tracerPlayer]);
        }

    }
}

// Triggers
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Tracer - Spawned
//--------------------------------------------------------------------------------------------------
bool libTrac_gt_HeroTracerSpawned_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_player;

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

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

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

    libGame_gv_players[lv_player].lv_vOHeroHasCustomKillVO = true;
    if ((libGame_gv_players[lv_player].lv_mountData.lv_mountModel == "MountTracerBikeOWC20")) {
        libNtve_gf_SendActorMessageToUnit(libGame_gv_players[lv_player].lv_heroUnit, "StatusSet TracerBikeTurnAnim 1");
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libTrac_gt_HeroTracerSpawned_Init () {
    libTrac_gt_HeroTracerSpawned = TriggerCreate("libTrac_gt_HeroTracerSpawned_Func");
    libGame_gf_HeroSpawn(libTrac_gt_HeroTracerSpawned);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Tracer - Hero Weapon UI Initialize
//--------------------------------------------------------------------------------------------------
bool libTrac_gt_HeroTracerHeroWeaponUIInitialize_Func (bool testConds, bool runActions) {
    int init_i;

    // Variable Declarations
    int[6] lv_panels;
    int lv_currentPanelLayer;

    // Automatic Variable Declarations
    // Variable Initialization
    for (init_i = 0; init_i <= 5; init_i += 1) {
        lv_panels[init_i] = c_invalidDialogControlId;
    }

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

    DialogControlHookup(libUIUI_gv_fullscreenStatusPanel, c_triggerControlTypePanel, "TracerPulseBombFrame");
    lv_currentPanelLayer += 1;
    lv_panels[lv_currentPanelLayer] = DialogControlLastCreated();
    libTrac_gv_tracerUI.lv_tracerPulseBombFrame = DialogControlLastCreated();
    DialogControlSetVisible(DialogControlLastCreated(), PlayerGroupAll(), false);
    DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypeImage, "StuckTextImage");
    libTrac_gv_tracerUI.lv_tracerStuckTextImage = DialogControlLastCreated();
    return true;
}

//--------------------------------------------------------------------------------------------------
void libTrac_gt_HeroTracerHeroWeaponUIInitialize_Init () {
    libTrac_gt_HeroTracerHeroWeaponUIInitialize = TriggerCreate("libTrac_gt_HeroTracerHeroWeaponUIInitialize_Func");
    libCore_gf_IncludeModInitialization(libTrac_gt_HeroTracerHeroWeaponUIInitialize);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Tracer - Pulse Bomb Stuck Overlay On
//--------------------------------------------------------------------------------------------------
bool libTrac_gt_HeroTracerPulseBombStuckOverlayOn_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_unit;
    int lv_ownerOfUnit;

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

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

    if (((libGame_gf_UnitIsHero(lv_unit) == false) || (lv_ownerOfUnit > libCore_gv_bALMaxPlayers) || (lv_ownerOfUnit <= 0) || (UnitTypeTestAttribute(UnitGetType(lv_unit), c_unitAttributeSummoned) == true) || (UnitFilterMatch(lv_unit, 1, UnitFilter(0, 0, 0, (1 << (c_targetFilterHallucination - 32)))) == false))) {
        return true;
    }
    else {
        DialogControlSetVisible(libTrac_gv_tracerUI.lv_tracerPulseBombFrame, libCore_gv_playerGroupFromPlayer[lv_ownerOfUnit], true);
        DialogControlSendAnimationEvent(libTrac_gv_tracerUI.lv_tracerStuckTextImage, libCore_gv_playerGroupFromPlayer[lv_ownerOfUnit], "Trigger");
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libTrac_gt_HeroTracerPulseBombStuckOverlayOn_Init () {
    libTrac_gt_HeroTracerPulseBombStuckOverlayOn = TriggerCreate("libTrac_gt_HeroTracerPulseBombStuckOverlayOn_Func");
    TriggerEnable(libTrac_gt_HeroTracerPulseBombStuckOverlayOn, false);
    TriggerAddEventUnitBehaviorChange(libTrac_gt_HeroTracerPulseBombStuckOverlayOn, null, "TracerPulseBombDummyBehavior", c_unitBehaviorChangeCreate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Tracer - Pulse Bomb Stuck Overlay Off
//--------------------------------------------------------------------------------------------------
bool libTrac_gt_HeroTracerPulseBombStuckOverlayOff_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_unit;
    int lv_ownerOfUnit;

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

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

    if (((lv_ownerOfUnit > libCore_gv_bALMaxPlayers) || (lv_ownerOfUnit <= 0) || (UnitTypeTestAttribute(UnitGetType(lv_unit), c_unitAttributeSummoned) == true) || (UnitFilterMatch(lv_unit, 1, UnitFilter(0, 0, 0, (1 << (c_targetFilterHallucination - 32)))) == false))) {
        return true;
    }
    else {
        Wait(1.0, c_timeGame);
        DialogControlSetVisible(libTrac_gv_tracerUI.lv_tracerPulseBombFrame, libCore_gv_playerGroupFromPlayer[lv_ownerOfUnit], false);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libTrac_gt_HeroTracerPulseBombStuckOverlayOff_Init () {
    libTrac_gt_HeroTracerPulseBombStuckOverlayOff = TriggerCreate("libTrac_gt_HeroTracerPulseBombStuckOverlayOff_Func");
    TriggerEnable(libTrac_gt_HeroTracerPulseBombStuckOverlayOff, false);
    TriggerAddEventUnitBehaviorChange(libTrac_gt_HeroTracerPulseBombStuckOverlayOff, null, "TracerPulseBombDummyBehavior", c_unitBehaviorChangeDestroy);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Tracer - Custom Kill VO
//--------------------------------------------------------------------------------------------------
bool libTrac_gt_HeroTracerCustomKillVO_Func (bool testConds, bool runActions) {
    // Variable Declarations
    string lv_killingEffect;
    int lv_killingPlayer;
    int lv_deadPlayer;
    int lv_speakingPlayer;
    string lv_killLine;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_killingPlayer = libGame_gf_CustomKillVOKillingPlayer();
    lv_deadPlayer = libGame_gf_CustomKillVODeadPlayer();
    lv_speakingPlayer = libGame_gf_CustomKillVOSpeakingPlayer();
    lv_killLine = libGame_gf_CustomKillVOKillLine();

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

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

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

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

    lv_killingEffect = libGame_gv_deathRecap_DeathData[lv_deadPlayer].lv_effectBars[1].lv_effect;
    if (((lv_killingEffect == "TracerPulseBombAoEDamage") || (lv_killingEffect == "TracerPulseBombAoECenterDamage") || (lv_killingEffect == "TracerPulseBombCompositionBPulseBombDamage") || (lv_killingEffect == "TracerPulseBombCompositionBPulseBombAoEDamage") || (lv_killingEffect == "TracerPulseBombQuantumSpikeMasteryAoEDamage") || (lv_killingEffect == "TracerPulseBombQuantumSpikeMasteryAoEPercentDamage") || (lv_killingEffect == "TracerPulseBombCompositionBQuantumSpikeDamage") || (lv_killingEffect == "TracerPulseBombCompositionBQuantumSpikePercentDamage"))) {
        if ((libGame_gv_players[lv_killingPlayer].lv_selectedSkin == libCore_gf_DataSkinsGetSkinIndexFromSkinLink("TracerSpectre"))) {
            lv_killLine = ("TracerSpectre_Pulsebomb_Successful");
        }
        else {
            lv_killLine = ("TracerBase_Pulsebomb_Successful");
        }
        lv_speakingPlayer = lv_killingPlayer;
    }
    else if (((lv_killingEffect == "TracerPulseBombDamage") || (lv_killingEffect == "TracerPulseBombQuantumSpikeMasteryDamage") || (lv_killingEffect == "TracerPulseBombQuantumSpikeMasteryPercentDamage"))) {
        if ((libGame_gv_players[lv_killingPlayer].lv_selectedSkin == libCore_gf_DataSkinsGetSkinIndexFromSkinLink("TracerSpectre"))) {
            lv_killLine = ("TracerSpectre_Pulsebomb_Stuck");
        }
        else {
            lv_killLine = ("TracerBase_Pulsebomb_Stuck");
        }
        lv_speakingPlayer = lv_killingPlayer;
    }
    libSond_gf_HeroVOPlayKillLine((lv_killLine), lv_speakingPlayer, lv_killingPlayer);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libTrac_gt_HeroTracerCustomKillVO_Init () {
    libTrac_gt_HeroTracerCustomKillVO = TriggerCreate("libTrac_gt_HeroTracerCustomKillVO_Func");
    TriggerEnable(libTrac_gt_HeroTracerCustomKillVO, false);
    libGame_gf_CustomKillVO(libTrac_gt_HeroTracerCustomKillVO);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Tracer - Reload - Restore Ammo On Hearth/Mount
//--------------------------------------------------------------------------------------------------
bool libTrac_gt_HeroTracerReloadRestoreAmmoOnHearthMount_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_caster;

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

    // Conditions
    if (testConds) {
        if (!((UnitGetType(lv_caster) == "HeroTracer"))) {
            return false;
        }
    }

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

    UnitCreateEffectUnit(lv_caster, "TracerReloadCastSet", lv_caster);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libTrac_gt_HeroTracerReloadRestoreAmmoOnHearthMount_Init () {
    libTrac_gt_HeroTracerReloadRestoreAmmoOnHearthMount = TriggerCreate("libTrac_gt_HeroTracerReloadRestoreAmmoOnHearthMount_Func");
    TriggerEnable(libTrac_gt_HeroTracerReloadRestoreAmmoOnHearthMount, false);
    TriggerAddEventPlayerEffectUsed(libTrac_gt_HeroTracerReloadRestoreAmmoOnHearthMount, c_playerAny, "MountInitialSet");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Tracer - Untouchable - Proc
//--------------------------------------------------------------------------------------------------
bool libTrac_gt_HeroTracerUntouchableProc_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_player;
    unit lv_tracer;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_player = libGame_gf_HeroParticipatedInTakedownKillingPlayer();
    lv_tracer = libGame_gv_players[lv_player].lv_heroUnit;

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

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

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

        if (!((PlayerHasTalent(lv_player, "TracerUntouchable") == true))) {
            return false;
        }

        if (!((UnitGetTokenCount(lv_tracer, CatalogFieldValueGet(c_gameCatalogBehavior, "TracerUntouchableQuestToken", "TokenId", c_playerAny)) < CatalogFieldValueGetAsInt(c_gameCatalogBehavior, "TracerUntouchableQuestToken", "Max", c_playerAny)))) {
            return false;
        }
    }

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

    UnitCreateEffectUnit(lv_tracer, "TracerUntouchableQuestIncrementToken", lv_tracer);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libTrac_gt_HeroTracerUntouchableProc_Init () {
    libTrac_gt_HeroTracerUntouchableProc = TriggerCreate("libTrac_gt_HeroTracerUntouchableProc_Func");
    TriggerEnable(libTrac_gt_HeroTracerUntouchableProc, false);
    libGame_gf_HeroParticipatedInTakedown(libTrac_gt_HeroTracerUntouchableProc);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Tracer - Spatial Echo - Proc
//--------------------------------------------------------------------------------------------------
bool libTrac_gt_HeroTracerSpatialEchoProc_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_player;
    unit lv_tracer;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_player = libGame_gf_HeroParticipatedInTakedownKillingPlayer();
    lv_tracer = libGame_gv_players[lv_player].lv_heroUnit;

    // Conditions
    if (testConds) {
        if (!((PlayerHasTalent(lv_player, "TracerSpatialEcho") == true))) {
            return false;
        }

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

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

    UnitCreateEffectUnit(lv_tracer, "TracerRecallSpatialEchoMasteryModifyUnit", lv_tracer);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libTrac_gt_HeroTracerSpatialEchoProc_Init () {
    libTrac_gt_HeroTracerSpatialEchoProc = TriggerCreate("libTrac_gt_HeroTracerSpatialEchoProc_Func");
    TriggerEnable(libTrac_gt_HeroTracerSpatialEchoProc, false);
    libGame_gf_HeroParticipatedInTakedown(libTrac_gt_HeroTracerSpatialEchoProc);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Tracer - Pulse Bomb - Set Facing
//--------------------------------------------------------------------------------------------------
bool libTrac_gt_HeroTracerPulseBombSetFacing_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libNtve_gf_MakeUnitFacePoint(EventUnit(), EventUnitTargetPoint(), 0.125);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libTrac_gt_HeroTracerPulseBombSetFacing_Init () {
    libTrac_gt_HeroTracerPulseBombSetFacing = TriggerCreate("libTrac_gt_HeroTracerPulseBombSetFacing_Func");
    TriggerEnable(libTrac_gt_HeroTracerPulseBombSetFacing, false);
    TriggerAddEventUnitAbility(libTrac_gt_HeroTracerPulseBombSetFacing, null, AbilityCommand("TracerPulseBomb", 0), c_unitAbilStageExecute, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Tracer - Focus Fire Cleanup
//--------------------------------------------------------------------------------------------------
bool libTrac_gt_HeroTracerFocusFireCleanup_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_player;

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

    // Conditions
    if (testConds) {
        if (!((PlayerHasTalent(lv_player, "TracerFocusFire") == true))) {
            return false;
        }
    }

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

    libTrac_gv_heroTracerFocusFireTargetInteger[lv_player] = 0;
    libTrac_gv_heroTracerFocusFireTarget[lv_player] = null;
    return true;
}

//--------------------------------------------------------------------------------------------------
void libTrac_gt_HeroTracerFocusFireCleanup_Init () {
    libTrac_gt_HeroTracerFocusFireCleanup = TriggerCreate("libTrac_gt_HeroTracerFocusFireCleanup_Func");
    TriggerEnable(libTrac_gt_HeroTracerFocusFireCleanup, false);
    TriggerAddEventUnitBehaviorChange(libTrac_gt_HeroTracerFocusFireCleanup, null, "TracerReload", c_unitBehaviorChangeDeactivate);
    TriggerAddEventUnitBehaviorChange(libTrac_gt_HeroTracerFocusFireCleanup, null, "TracerRecallActive", c_unitBehaviorChangeDeactivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Tracer - Focus Fire Set Target
//--------------------------------------------------------------------------------------------------
bool libTrac_gt_HeroTracerFocusFireSetTarget_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_target;
    unit lv_caster;
    int lv_ownerOfCaster;

    // Automatic Variable Declarations
    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((PlayerHasTalent(UnitGetOwner(EventPlayerEffectUsedUnit(c_effectUnitCaster)), "TracerFocusFire") == true))) {
            return false;
        }
    }

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

    lv_ownerOfCaster = UnitGetOwner(EventPlayerEffectUsedUnit(c_effectUnitCaster));
    lv_target = EventPlayerEffectUsedUnit(c_effectUnitTarget);
    lv_caster = EventPlayerEffectUsedUnit(c_effectUnitCaster);
    if ((libTrac_gv_heroTracerFocusFireTarget[lv_ownerOfCaster] == lv_target)) {
        libTrac_gv_heroTracerFocusFireTargetInteger[lv_ownerOfCaster] += 1;
    }
    else {
        libTrac_gv_heroTracerFocusFireTargetInteger[lv_ownerOfCaster] = 1;
        libTrac_gv_heroTracerFocusFireTarget[lv_ownerOfCaster] = lv_target;
    }
    if ((libTrac_gv_heroTracerFocusFireTargetInteger[lv_ownerOfCaster] == 10)) {
        if ((UnitFilterMatch(lv_target, lv_ownerOfCaster, UnitFilter((1 << c_targetFilterHeroic), 0, (1 << c_targetFilterPlayer) | (1 << c_targetFilterAlly), 0)) == true)) {
            UnitCreateEffectUnitWithSource(lv_caster, "TracerFocusFireHeroImpactSet", lv_target, c_gameCatalogBehavior, "TracerFocusFireFinalShot");
        }
        else {
            UnitCreateEffectUnitWithSource(lv_caster, "TracerFocusFireNonHeroImpactSet", lv_target, c_gameCatalogBehavior, "TracerFocusFireFinalShot");
        }
        libTrac_gv_heroTracerFocusFireTargetInteger[lv_ownerOfCaster] = 0;
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libTrac_gt_HeroTracerFocusFireSetTarget_Init () {
    libTrac_gt_HeroTracerFocusFireSetTarget = TriggerCreate("libTrac_gt_HeroTracerFocusFireSetTarget_Func");
    TriggerEnable(libTrac_gt_HeroTracerFocusFireSetTarget, false);
    TriggerAddEventPlayerEffectUsed(libTrac_gt_HeroTracerFocusFireSetTarget, c_playerAny, "TracerHeroWeaponImpactSet");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Tracer - Focus Fire Increment Cooldown
//--------------------------------------------------------------------------------------------------
bool libTrac_gt_HeroTracerFocusFireIncrementCooldown_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_unit;
    int lv_owner;

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

    // Conditions
    if (testConds) {
        if (!((UnitBehaviorCount(lv_unit, "UltimateEvolutionBuff") == 0))) {
            return false;
        }

        if (!((UnitGetType(lv_unit) == "HeroTracer"))) {
            return false;
        }
    }

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

    libTrac_gv_heroTracerFocusFireTargetInteger[lv_owner] = 0;
    libTrac_gv_heroTracerFocusFireTarget[lv_owner] = null;
    return true;
}

//--------------------------------------------------------------------------------------------------
void libTrac_gt_HeroTracerFocusFireIncrementCooldown_Init () {
    libTrac_gt_HeroTracerFocusFireIncrementCooldown = TriggerCreate("libTrac_gt_HeroTracerFocusFireIncrementCooldown_Func");
    TriggerEnable(libTrac_gt_HeroTracerFocusFireIncrementCooldown, false);
    TriggerAddEventUnitBehaviorChange(libTrac_gt_HeroTracerFocusFireIncrementCooldown, null, "TracerFocusFireIncrementCooldown", c_unitBehaviorChangeDeactivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Tracer - Hero Weapon Apply Targeting Unit
//--------------------------------------------------------------------------------------------------
bool libTrac_gt_HeroTracerHeroWeaponApplyTargetingUnit_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_tracerUnit;
    unit lv_targetUnit;
    point lv_targetPoint;
    int lv_tracerPlayer;
    abilcmd lv_ability;
    bool lv_hadHoldFire;
    bool lv_hadDisabler;
    bool lv_hadMountedDisabler;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_ability = EventUnitAbility();

    // Conditions
    if (testConds) {
        if (!((UnitGetType(EventUnit()) == "HeroTracer"))) {
            return false;
        }
    }

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

    lv_tracerUnit = EventUnit();
    lv_tracerPlayer = UnitGetOwner(EventUnit());
    lv_targetUnit = EventUnitTargetUnit();
    if ((lv_targetUnit != null) && (UnitFilterMatch(lv_targetUnit, lv_tracerPlayer, UnitFilter(0, 0, (1 << c_targetFilterPlayer) | (1 << c_targetFilterAlly) | (1 << c_targetFilterMissile) | (1 << c_targetFilterItem), (1 << (c_targetFilterStasis - 32)) | (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)) | (1 << (c_targetFilterInvulnerable - 32)))) == true)) {
        if ((lv_targetUnit == libTrac_gv_heroTracerCurrentAttackTarget[lv_tracerPlayer]) && (UnitHasBehavior2(libTrac_gv_heroTracerCurrentAttackTarget[lv_tracerPlayer], "TracerHeroWeaponTargeting") == true)) {
            return true;
        }

        if ((libTrac_gv_heroTracerCurrentAttackTarget[lv_tracerPlayer] != null) && (libTrac_gv_heroTracerCurrentAttackTarget[lv_tracerPlayer] != lv_targetUnit) && (UnitHasBehavior2(libTrac_gv_heroTracerCurrentAttackTarget[lv_tracerPlayer], "TracerHeroWeaponTargeting") == true)) {
            UnitCreateEffectUnit(lv_tracerUnit, "TracerHeroWeaponRemoveTargetingBehavior", libTrac_gv_heroTracerCurrentAttackTarget[lv_tracerPlayer]);
        }

        UnitBehaviorRemove(lv_tracerUnit, "TracerHeroWeaponDisablerHoldFire", 1);
        UnitCreateEffectUnit(lv_tracerUnit, "TracerHeroWeaponClearWeaponTargets", lv_tracerUnit);
        UnitCreateEffectUnit(lv_tracerUnit, "TracerHeroWeaponApplyTargetingBehavior", lv_targetUnit);
        libTrac_gv_heroTracerCurrentAttackTarget[lv_tracerPlayer] = lv_targetUnit;
        UnitBehaviorAdd(lv_tracerUnit, "TracerHeroWeaponCasterTargetFinderDisabler", lv_tracerUnit, 1);
    }
    else {
        if ((EventUnitTargetPoint() != null) && (DistanceBetweenPoints(EventUnitTargetPoint(), UnitGetPosition(lv_tracerUnit)) > 0.0)) {
            if ((UnitHasBehavior2(lv_tracerUnit, "TracerHeroWeaponCasterTargetFinderDisabler") == true)) {
                lv_hadDisabler = true;
                UnitBehaviorRemove(lv_tracerUnit, "TracerHeroWeaponCasterTargetFinderDisabler", 1);
            }

            if ((UnitHasBehavior2(lv_tracerUnit, "HeroWeaponCasterTargetFinderDisablerMounted") == true)) {
                lv_hadMountedDisabler = true;
                UnitBehaviorRemove(lv_tracerUnit, "HeroWeaponCasterTargetFinderDisablerMounted", 1);
            }

            if ((UnitHasBehavior2(lv_tracerUnit, "HoldFire") == true)) {
                lv_hadHoldFire = true;
                UnitBehaviorAdd(lv_tracerUnit, "TracerHoldFireDisabler", lv_tracerUnit, 1);
            }

            lv_targetPoint = EventUnitTargetPoint();
            while (!((UnitOrder(lv_tracerUnit, 0) != OrderTargetingPoint(AbilityCommand("TracerAttack", 0), lv_targetPoint)))) {
                Wait(0.125, c_timeGame);
            }
            if ((lv_hadDisabler == true)) {
                lv_hadDisabler = false;
                UnitBehaviorAdd(lv_tracerUnit, "TracerHeroWeaponCasterTargetFinderDisabler", lv_tracerUnit, 1);
            }

            if ((lv_hadMountedDisabler == true)) {
                lv_hadMountedDisabler = false;
                UnitBehaviorAdd(lv_tracerUnit, "HeroWeaponCasterTargetFinderDisablerMounted", lv_tracerUnit, 1);
            }

            if ((lv_hadHoldFire == true)) {
                lv_hadHoldFire = false;
                UnitBehaviorRemove(lv_tracerUnit, "TracerHoldFireDisabler", 1);
            }

        }

    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libTrac_gt_HeroTracerHeroWeaponApplyTargetingUnit_Init () {
    libTrac_gt_HeroTracerHeroWeaponApplyTargetingUnit = TriggerCreate("libTrac_gt_HeroTracerHeroWeaponApplyTargetingUnit_Func");
    TriggerEnable(libTrac_gt_HeroTracerHeroWeaponApplyTargetingUnit, false);
    TriggerAddEventUnitAbility(libTrac_gt_HeroTracerHeroWeaponApplyTargetingUnit, null, AbilityCommand("TracerSmartTargetingRightClick", 0), c_abilEffectStageApproach, false);
    TriggerAddEventUnitAbility(libTrac_gt_HeroTracerHeroWeaponApplyTargetingUnit, null, AbilityCommand("TracerSmartTargetingRightClick", 0), c_abilEffectStageCast, false);
    TriggerAddEventUnitAbility(libTrac_gt_HeroTracerHeroWeaponApplyTargetingUnit, null, AbilityCommand("TracerTargetingAttackClick", 0), c_unitAbilStageExecute, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Tracer - Target Acquired
//--------------------------------------------------------------------------------------------------
bool libTrac_gt_HeroTracerTargetAcquired_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_unit;
    int lv_tracerPlayer;
    unit lv_tracer;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_unit = EventPlayerEffectUsedUnit(c_effectUnitTarget);
    lv_tracerPlayer = UnitGetOwner(EventPlayerEffectUsedUnit(c_effectUnitCaster));

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

        if (!((lv_unit != libTrac_gv_heroTracerCurrentAttackTarget[lv_tracerPlayer]))) {
            return false;
        }
    }

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

    lv_tracer = EventPlayerEffectUsedUnit(c_effectUnitCaster);
    if ((libTrac_gv_heroTracerCurrentAttackTarget[lv_tracerPlayer] != null) && (UnitHasBehavior2(libTrac_gv_heroTracerCurrentAttackTarget[lv_tracerPlayer], "TracerHeroWeaponTargeting") == true)) {
        UnitCreateEffectUnit(lv_tracer, "TracerHeroWeaponRemoveTargetingBehavior", libTrac_gv_heroTracerCurrentAttackTarget[lv_tracerPlayer]);
    }

    UnitCreateEffectUnit(lv_tracer, "TracerHeroWeaponCasterTargetApplyDisablerBehavior", lv_tracer);
    libTrac_gv_heroTracerCurrentAttackTarget[lv_tracerPlayer] = lv_unit;
    return true;
}

//--------------------------------------------------------------------------------------------------
void libTrac_gt_HeroTracerTargetAcquired_Init () {
    libTrac_gt_HeroTracerTargetAcquired = TriggerCreate("libTrac_gt_HeroTracerTargetAcquired_Func");
    TriggerEnable(libTrac_gt_HeroTracerTargetAcquired, false);
    TriggerAddEventPlayerEffectUsed(libTrac_gt_HeroTracerTargetAcquired, c_playerAny, "TracerHeroWeaponNewTargetImpactSet");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Tracer - Force Acquire Target (Taunt)
//--------------------------------------------------------------------------------------------------
bool libTrac_gt_HeroTracerForceAcquireTargetTaunt_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_unittoAttack;
    unit lv_tracerUnit;
    int lv_tracerPlayer;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_unittoAttack = EventPlayerEffectUsedUnit(c_effectUnitCaster);
    lv_tracerUnit = EventPlayerEffectUsedUnit(c_effectUnitTarget);
    lv_tracerPlayer = UnitGetOwner(lv_tracerUnit);

    // Conditions
    if (testConds) {
        if (!((UnitGetType(lv_tracerUnit) == "HeroTracer"))) {
            return false;
        }
    }

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

    UnitIssueOrder(lv_tracerUnit, OrderTargetingUnit(AbilityCommand("TracerSmartTargetingRightClick", 0), lv_unittoAttack), c_orderQueueReplace);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libTrac_gt_HeroTracerForceAcquireTargetTaunt_Init () {
    libTrac_gt_HeroTracerForceAcquireTargetTaunt = TriggerCreate("libTrac_gt_HeroTracerForceAcquireTargetTaunt_Func");
    TriggerEnable(libTrac_gt_HeroTracerForceAcquireTargetTaunt, false);
    TriggerAddEventPlayerEffectUsed(libTrac_gt_HeroTracerForceAcquireTargetTaunt, c_playerAny, "ForceTargetToAttackCasterUnitScriptDummy");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Tracer - Hold Fire
//--------------------------------------------------------------------------------------------------
bool libTrac_gt_HeroTracerHoldFire_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_tracer;

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

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

        if (!((UnitGetType(lv_tracer) == "HeroTracer"))) {
            return false;
        }
    }

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

    UnitBehaviorAdd(lv_tracer, "TracerHeroWeaponDisablerHoldFire", lv_tracer, 1);
    libTrac_gv_heroTracerCurrentAttackTarget[UnitGetOwner(EventUnit())] = null;
    return true;
}

//--------------------------------------------------------------------------------------------------
void libTrac_gt_HeroTracerHoldFire_Init () {
    libTrac_gt_HeroTracerHoldFire = TriggerCreate("libTrac_gt_HeroTracerHoldFire_Func");
    TriggerEnable(libTrac_gt_HeroTracerHoldFire, false);
    TriggerAddEventUnitOrder(libTrac_gt_HeroTracerHoldFire, null, AbilityCommand("HoldFire", 1));
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Tracer - Clear Target Via Effect
//--------------------------------------------------------------------------------------------------
bool libTrac_gt_HeroTracerClearTargetViaEffect_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_tracerPlayer;
    unit lv_tracer;

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

    // Conditions
    if (testConds) {
        if (!((UnitGetType(lv_tracer) == "HeroTracer"))) {
            return false;
        }

        if (!((libTrac_gv_heroTracerCurrentAttackTarget[lv_tracerPlayer] != null))) {
            return false;
        }
    }

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

    UnitCreateEffectUnit(lv_tracer, "TracerHeroWeaponRemoveTargetingBehavior", libTrac_gv_heroTracerCurrentAttackTarget[lv_tracerPlayer]);
    libTrac_gv_heroTracerCurrentAttackTarget[lv_tracerPlayer] = null;
    return true;
}

//--------------------------------------------------------------------------------------------------
void libTrac_gt_HeroTracerClearTargetViaEffect_Init () {
    libTrac_gt_HeroTracerClearTargetViaEffect = TriggerCreate("libTrac_gt_HeroTracerClearTargetViaEffect_Func");
    TriggerEnable(libTrac_gt_HeroTracerClearTargetViaEffect, false);
    TriggerAddEventPlayerEffectUsed(libTrac_gt_HeroTracerClearTargetViaEffect, c_playerAny, "TracerHeroWeaponApplyWeaponDisabler");
    TriggerAddEventPlayerEffectUsed(libTrac_gt_HeroTracerClearTargetViaEffect, c_playerAny, "TracerDeathSet");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Tracer - Update Recall Record
//--------------------------------------------------------------------------------------------------
bool libTrac_gt_HeroTracerUpdateRecallRecord_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_itIndex;
    int lv_player;
    unit lv_tracer;

    // Automatic Variable Declarations
    const int autoA53E1488_ae = 2;
    const int autoA53E1488_ai = -1;

    // Variable Initialization

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

    lv_tracer = EventPlayerEffectUsedUnit(c_effectUnitCaster);
    if ((lv_tracer == null)) {
        return true;
    }

    lv_player = UnitGetOwner(lv_tracer);
    if ((libTrac_gv_tracerRecallDebugMode == true)) {
        UnitRemove(libTrac_gv_tracerRecallRecordVariable[lv_player][libTrac_gv_tracerRecallTrackCountMax].lv_debugUnit);
        TextTagDestroy(libTrac_gv_tracerRecallRecordVariable[lv_player][libTrac_gv_tracerRecallTrackCountMax].lv_tempTextTag);
    }

    lv_itIndex = libTrac_gv_tracerRecallTrackCountMax;
    for ( ; ( (autoA53E1488_ai >= 0 && lv_itIndex <= autoA53E1488_ae) || (autoA53E1488_ai < 0 && lv_itIndex >= autoA53E1488_ae) ) ; lv_itIndex += autoA53E1488_ai ) {
        libTrac_gv_tracerRecallRecordVariable[lv_player][lv_itIndex].lv_position = libTrac_gv_tracerRecallRecordVariable[lv_player][(lv_itIndex - 1)].lv_position;
        libTrac_gv_tracerRecallRecordVariable[lv_player][lv_itIndex].lv_positionPathable = libTrac_gv_tracerRecallRecordVariable[lv_player][(lv_itIndex - 1)].lv_positionPathable;
        libTrac_gv_tracerRecallRecordVariable[lv_player][lv_itIndex].lv_health = libTrac_gv_tracerRecallRecordVariable[lv_player][(lv_itIndex - 1)].lv_health;
        if ((libTrac_gv_tracerRecallDebugMode == true)) {
            libTrac_gv_tracerRecallRecordVariable[lv_player][lv_itIndex].lv_tempTextTag = libTrac_gv_tracerRecallRecordVariable[lv_player][(lv_itIndex - 1)].lv_tempTextTag;
            TextTagSetText(libTrac_gv_tracerRecallRecordVariable[lv_player][lv_itIndex].lv_tempTextTag, IntToText(lv_itIndex));
            libTrac_gv_tracerRecallRecordVariable[lv_player][lv_itIndex].lv_debugUnit = libTrac_gv_tracerRecallRecordVariable[lv_player][(lv_itIndex - 1)].lv_debugUnit;
        }

    }
    if ((libGame_gv_players[lv_player].lv_activeVehicle == null)) {
        libTrac_gv_tracerRecallRecordVariable[lv_player][1].lv_position = UnitGetPosition(lv_tracer);
    }
    else {
        libTrac_gv_tracerRecallRecordVariable[lv_player][1].lv_position = UnitGetPosition(libGame_gv_players[lv_player].lv_activeVehicle);
    }
    if ((PointPathingPassable(libTrac_gv_tracerRecallRecordVariable[lv_player][1].lv_position) == true)) {
        libTrac_gv_tracerRecallRecordVariable[lv_player][1].lv_positionPathable = true;
    }
    else {
        if ((libTrac_gv_tracerRecallDebugMode == true)) {
            TriggerDebugOutput(1, StringExternal("Param/Value/lib_Trac_8F423893"), true);
        }

        libTrac_gv_tracerRecallRecordVariable[lv_player][1].lv_positionPathable = false;
    }
    libTrac_gv_tracerRecallRecordVariable[lv_player][1].lv_health = UnitGetPropertyFixed(lv_tracer, c_unitPropLife, c_unitPropCurrent);
    libTrac_gf_HeroTracerCreateorUpdateAIRecallTrackerUnit(lv_tracer);
    if ((libTrac_gv_tracerRecallDebugMode == true)) {
        UnitCreate(1, "TracerRecallDummyUnit", 0, lv_player, UnitGetPosition(lv_tracer), 270.0, lv_tracer);
        libTrac_gv_tracerRecallRecordVariable[lv_player][1].lv_debugUnit = UnitLastCreated();
        TextTagCreate(StringExternal("Param/Value/lib_Trac_B83FDB20"), 12, UnitGetPosition(libTrac_gv_tracerRecallRecordVariable[lv_player][1].lv_debugUnit), 1.0, true, false, PlayerGroupSingle(lv_player));
        libTrac_gv_tracerRecallRecordVariable[lv_player][1].lv_tempTextTag = TextTagLastCreated();
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libTrac_gt_HeroTracerUpdateRecallRecord_Init () {
    libTrac_gt_HeroTracerUpdateRecallRecord = TriggerCreate("libTrac_gt_HeroTracerUpdateRecallRecord_Func");
    TriggerEnable(libTrac_gt_HeroTracerUpdateRecallRecord, false);
    TriggerAddEventPlayerEffectUsed(libTrac_gt_HeroTracerUpdateRecallRecord, c_playerAny, "TracerRecallPeriodicDummy");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Tracer - Update Recall on Tracer Hearth
//--------------------------------------------------------------------------------------------------
bool libTrac_gt_HeroTracerUpdateRecallonTracerHearth_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_triggeringEffectUnit;
    int lv_i;
    int lv_player;

    // Automatic Variable Declarations
    const int auto929C5F95_ae = 1;
    const int auto929C5F95_ai = -1;

    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((UnitGetType(EventPlayerEffectUsedUnit(c_effectUnitCaster)) == "HeroTracer"))) {
            return false;
        }
    }

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

    lv_triggeringEffectUnit = EventPlayerEffectUsedUnit(c_effectUnitCaster);
    if ((lv_triggeringEffectUnit == null)) {
        return true;
    }

    lv_player = UnitGetOwner(lv_triggeringEffectUnit);
    lv_i = libTrac_gv_tracerRecallTrackCountMax;
    for ( ; ( (auto929C5F95_ai >= 0 && lv_i <= auto929C5F95_ae) || (auto929C5F95_ai < 0 && lv_i >= auto929C5F95_ae) ) ; lv_i += auto929C5F95_ai ) {
        libTrac_gv_tracerRecallRecordVariable[lv_player][lv_i].lv_position = UnitGetPosition(lv_triggeringEffectUnit);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libTrac_gt_HeroTracerUpdateRecallonTracerHearth_Init () {
    libTrac_gt_HeroTracerUpdateRecallonTracerHearth = TriggerCreate("libTrac_gt_HeroTracerUpdateRecallonTracerHearth_Func");
    TriggerEnable(libTrac_gt_HeroTracerUpdateRecallonTracerHearth, false);
    TriggerAddEventPlayerEffectUsed(libTrac_gt_HeroTracerUpdateRecallonTracerHearth, c_playerAny, "HearthstoneLaunchSet");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Tracer - Recall Cast
//--------------------------------------------------------------------------------------------------
bool libTrac_gt_HeroTracerRecallCast_Func (bool testConds, bool runActions) {
    // Variable Declarations
    point lv_castPoint;
    int lv_index;
    int lv_player;
    unit lv_tracer;

    // Automatic Variable Declarations
    // Variable Initialization

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

    lv_tracer = EventPlayerEffectUsedUnit(c_effectUnitCaster);
    lv_player = UnitGetOwner(lv_tracer);
    lv_castPoint = UnitGetPosition(lv_tracer);
    if ((PlayerHasTalent(lv_player, "TracerPartingGift") == true)) {
        UnitCreateEffectUnitWithSource(lv_tracer, "TracerRecallPartingGiftClusterInitialSet", lv_tracer, c_gameCatalogAbil, "TracerRecall");
    }

    lv_index = libTrac_gf_HeroTracerRecallDetermineIndex(lv_player);
    if ((lv_index >= 0)) {
        if ((libTrac_gv_tracerRecallDebugMode == true)) {
            TextExpressionSetToken("Param/Expression/lib_Trac_135A2F08", "A", IntToText(lv_index));
            TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Trac_135A2F08"), true);
        }

        UnitCreateEffectUnit(lv_tracer, "TracerReloadCastSet", lv_tracer);
        UnitCreateEffectPoint(lv_tracer, "TracerRecallTeleportSet", libTrac_gv_tracerRecallRecordVariable[lv_player][lv_index].lv_position);
        UnitCreateEffectPoint(lv_tracer, "TracerRecallVisualDummyFXCreateUnit", libTrac_gv_tracerRecallRecordVariable[lv_player][lv_index].lv_position);
        UnitCreateEffectPoint(lv_tracer, "TracerRecallLaunchModelMissile", lv_castPoint);
        CatalogFieldValueSetFixed(c_gameCatalogEffect, "TracerRecallTotalRecallHeal", "RechargeVitalRate", lv_player, (libTrac_gv_tracerRecallRecordVariable[lv_player][lv_index].lv_health-UnitGetPropertyFixed(lv_tracer, c_unitPropLife, c_unitPropCurrent)));
        if (((libTrac_gv_tracerRecallRecordVariable[lv_player][lv_index].lv_health + 0.2) > UnitGetPropertyFixed(lv_tracer, c_unitPropLife, c_unitPropCurrent)) && (PlayerHasTalent(lv_player, "TracerTotalRecallRecall") == true)) {
            CatalogFieldValueSetFixed(c_gameCatalogEffect, "TracerRecallTotalRecallHeal", "Chance", lv_player, 1.0);
        }
        else {
            CatalogFieldValueSetFixed(c_gameCatalogEffect, "TracerRecallTotalRecallHeal", "Chance", lv_player, 0.0);
        }
    }
    else {
        if ((libTrac_gv_tracerRecallDebugMode == true)) {
            TriggerDebugOutput(1, StringExternal("Param/Value/lib_Trac_550CAC33"), true);
        }

    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libTrac_gt_HeroTracerRecallCast_Init () {
    libTrac_gt_HeroTracerRecallCast = TriggerCreate("libTrac_gt_HeroTracerRecallCast_Func");
    TriggerEnable(libTrac_gt_HeroTracerRecallCast, false);
    TriggerAddEventPlayerEffectUsed(libTrac_gt_HeroTracerRecallCast, c_playerAny, "TracerRecallAbilityDummy");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Tracer - Recall Camera Lock
//--------------------------------------------------------------------------------------------------
bool libTrac_gt_HeroTracerRecallCameraLock_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_unit;
    int lv_ownerOfUnit;

    // Automatic Variable Declarations
    fixed autoF5F65934_at;

    // Variable Initialization
    lv_unit = EventUnit();
    lv_ownerOfUnit = UnitGetOwner(lv_unit);

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

    libGame_gv_players[lv_ownerOfUnit].lv_cameraPlayerUnitGroupToFocusOn = libNtve_gf_ConvertUnitToUnitGroup(lv_unit);
    libGame_gv_players[lv_ownerOfUnit].lv_cameraForcedLock = true;
    Wait(0.1875, c_timeGame);
    libGame_gf_CameraUpdateCameraForPlayer(lv_ownerOfUnit);
    autoF5F65934_at = 0;
    while (!((UnitHasBehavior2(lv_unit, "TracerRecallActive") == false)) && autoF5F65934_at <= 2.0) {
        Wait(0.0625, c_timeGame);
        autoF5F65934_at = autoF5F65934_at + 0.0625;
    }
    libGame_gv_players[lv_ownerOfUnit].lv_cameraForcedLock = false;
    libGame_gf_CameraUpdateCameraForPlayer(lv_ownerOfUnit);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libTrac_gt_HeroTracerRecallCameraLock_Init () {
    libTrac_gt_HeroTracerRecallCameraLock = TriggerCreate("libTrac_gt_HeroTracerRecallCameraLock_Func");
    TriggerEnable(libTrac_gt_HeroTracerRecallCameraLock, false);
    TriggerAddEventUnitBehaviorChange(libTrac_gt_HeroTracerRecallCameraLock, null, "TracerRecallActive", c_unitBehaviorChangeActivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Tracer - Recall Debug Mode
//--------------------------------------------------------------------------------------------------
bool libTrac_gt_HeroTracerRecallDebugMode_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {
            return false;
        }
    }

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

    if ((libTrac_gv_tracerRecallDebugMode == true)) {
        libTrac_gv_tracerRecallDebugMode = false;
    }
    else {
        libTrac_gv_tracerRecallDebugMode = true;
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libTrac_gt_HeroTracerRecallDebugMode_Init () {
    libTrac_gt_HeroTracerRecallDebugMode = TriggerCreate("libTrac_gt_HeroTracerRecallDebugMode_Func");
    TriggerEnable(libTrac_gt_HeroTracerRecallDebugMode, false);
    TriggerAddEventChatMessage(libTrac_gt_HeroTracerRecallDebugMode, c_playerAny, "-trd", true);
    TriggerAddEventChatMessage(libTrac_gt_HeroTracerRecallDebugMode, c_playerAny, "-recalldebug", true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Tracer - Ultimate Evolution Recall
//--------------------------------------------------------------------------------------------------
bool libTrac_gt_HeroTracerUltimateEvolutionRecall_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_player;
    unit lv_tracer;

    // Automatic Variable Declarations
    // Variable Initialization

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

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

    lv_player = libGDHL_gf_AbathurUltimateEvolutionHeroCopiedAbathurOwner();
    lv_tracer = libGame_gv_players[lv_player].lv_activeVehicle;
    libTrac_gf_HeroTracerResetAllRecallPointstoCurrentPosition(lv_player, lv_tracer);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libTrac_gt_HeroTracerUltimateEvolutionRecall_Init () {
    libTrac_gt_HeroTracerUltimateEvolutionRecall = TriggerCreate("libTrac_gt_HeroTracerUltimateEvolutionRecall_Func");
    TriggerEnable(libTrac_gt_HeroTracerUltimateEvolutionRecall, false);
    libGDHL_gf_AbathurUltimateEvolutionHeroCopied(libTrac_gt_HeroTracerUltimateEvolutionRecall);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Tracer - Ultimate Evolution Kill Recall Tracker
//--------------------------------------------------------------------------------------------------
bool libTrac_gt_HeroTracerUltimateEvolutionKillRecallTracker_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((UnitGetType(libGDHL_gf_AbathurUltimateEvolutionEndedClonedUnit()) == "HeroTracer"))) {
            return false;
        }
    }

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

    UnitBehaviorRemove(libGDHL_gf_AbathurUltimateEvolutionEndedClonedUnit(), "TracerRecallController", 1);
    if ((UnitIsValid(libTrac_gv_tracerRecallUnit[libGDHL_gf_AbathurUltimateEvolutionEndedAbathurPlayer()]) == true)) {
        UnitRemove(libTrac_gv_tracerRecallUnit[libGDHL_gf_AbathurUltimateEvolutionEndedAbathurPlayer()]);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libTrac_gt_HeroTracerUltimateEvolutionKillRecallTracker_Init () {
    libTrac_gt_HeroTracerUltimateEvolutionKillRecallTracker = TriggerCreate("libTrac_gt_HeroTracerUltimateEvolutionKillRecallTracker_Func");
    libGDHL_gf_AbathurUltimateEvolutionEnded(libTrac_gt_HeroTracerUltimateEvolutionKillRecallTracker);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Tracer - Update Recall Points on Revive
//--------------------------------------------------------------------------------------------------
bool libTrac_gt_HeroTracerUpdateRecallPointsonRevive_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_player;
    unit lv_tracer;

    // Automatic Variable Declarations
    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((UnitGetType(EventUnit()) == "HeroTracer"))) {
            return false;
        }
    }

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

    lv_tracer = EventUnit();
    lv_player = UnitGetOwner(lv_tracer);
    libTrac_gf_HeroTracerResetAllRecallPointstoCurrentPosition(lv_player, lv_tracer);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libTrac_gt_HeroTracerUpdateRecallPointsonRevive_Init () {
    libTrac_gt_HeroTracerUpdateRecallPointsonRevive = TriggerCreate("libTrac_gt_HeroTracerUpdateRecallPointsonRevive_Func");
    TriggerEnable(libTrac_gt_HeroTracerUpdateRecallPointsonRevive, false);
    TriggerAddEventUnitRevive(libTrac_gt_HeroTracerUpdateRecallPointsonRevive, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Tracer - Melee - Set Facing
//--------------------------------------------------------------------------------------------------
bool libTrac_gt_HeroTracerMeleeSetFacing_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libNtve_gf_MakeUnitFacePoint(EventPlayerEffectUsedUnit(c_effectUnitCaster), UnitGetPosition(EventPlayerEffectUsedUnit(c_effectUnitTarget)), -1.0);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libTrac_gt_HeroTracerMeleeSetFacing_Init () {
    libTrac_gt_HeroTracerMeleeSetFacing = TriggerCreate("libTrac_gt_HeroTracerMeleeSetFacing_Func");
    TriggerEnable(libTrac_gt_HeroTracerMeleeSetFacing, false);
    TriggerAddEventPlayerEffectUsed(libTrac_gt_HeroTracerMeleeSetFacing, c_playerAny, "TracerMeleeImpactDelayPersistent");
}

void libTrac_InitTriggers () {
    libTrac_gt_HeroTracerSpawned_Init();
    libTrac_gt_HeroTracerHeroWeaponUIInitialize_Init();
    libTrac_gt_HeroTracerPulseBombStuckOverlayOn_Init();
    libTrac_gt_HeroTracerPulseBombStuckOverlayOff_Init();
    libTrac_gt_HeroTracerCustomKillVO_Init();
    libTrac_gt_HeroTracerReloadRestoreAmmoOnHearthMount_Init();
    libTrac_gt_HeroTracerUntouchableProc_Init();
    libTrac_gt_HeroTracerSpatialEchoProc_Init();
    libTrac_gt_HeroTracerPulseBombSetFacing_Init();
    libTrac_gt_HeroTracerFocusFireCleanup_Init();
    libTrac_gt_HeroTracerFocusFireSetTarget_Init();
    libTrac_gt_HeroTracerFocusFireIncrementCooldown_Init();
    libTrac_gt_HeroTracerHeroWeaponApplyTargetingUnit_Init();
    libTrac_gt_HeroTracerTargetAcquired_Init();
    libTrac_gt_HeroTracerForceAcquireTargetTaunt_Init();
    libTrac_gt_HeroTracerHoldFire_Init();
    libTrac_gt_HeroTracerClearTargetViaEffect_Init();
    libTrac_gt_HeroTracerUpdateRecallRecord_Init();
    libTrac_gt_HeroTracerUpdateRecallonTracerHearth_Init();
    libTrac_gt_HeroTracerRecallCast_Init();
    libTrac_gt_HeroTracerRecallCameraLock_Init();
    libTrac_gt_HeroTracerRecallDebugMode_Init();
    libTrac_gt_HeroTracerUltimateEvolutionRecall_Init();
    libTrac_gt_HeroTracerUltimateEvolutionKillRecallTracker_Init();
    libTrac_gt_HeroTracerUpdateRecallPointsonRevive_Init();
    libTrac_gt_HeroTracerMeleeSetFacing_Init();
}

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

void libTrac_InitLib () {
    if (libTrac_InitLib_completed) {
        return;
    }

    libTrac_InitLib_completed = true;

    libTrac_InitLibraries();
    libTrac_InitVariables();
    libTrac_InitTriggers();
}