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