mods/heromods/junkrat.stormmod/base.stormdata/libhjun.galaxy

libhjun.galaxy
include "TriggerLibs/NativeLib"
include "TriggerLibs/HeroesLib"
include "TriggerLibs/GameLib"
include "TriggerLibs/AILib"
include "TriggerLibs/UILib"

include "LibHJUN_h"

//--------------------------------------------------------------------------------------------------
// Library: Junkrat
//--------------------------------------------------------------------------------------------------
// External Library Initialization
void libHJUN_InitLibraries () {
    libNtve_InitVariables();
    libCore_InitVariables();
    libGame_InitVariables();
    libAIAI_InitVariables();
    libUIUI_InitVariables();
}

// Variable Initialization
bool libHJUN_InitVariables_completed = false;

void libHJUN_InitVariables () {
    int init_i;

    if (libHJUN_InitVariables_completed) {
        return;
    }

    libHJUN_InitVariables_completed = true;

    for (init_i = 0; init_i <= libHJUN_gv_heroJunkratMaxSteelTraps; init_i += 1) {
        libHJUN_gv_heroJunkratSteelTrapsFrames[init_i] = c_invalidDialogControlId;
    }
}

// Functions
void libHJUN_gf_HeroJunkratIncrementHeroCountFunction () {
    // Automatic Variable Declarations
    // Implementation
    libHJUN_gv_heroJunkratTriggerRegistrationVariable += 1;
    if ((libHJUN_gv_heroJunkratTriggerRegistrationVariable == 1)) {
        TriggerEnable(libHJUN_gt_HeroJunkratFragLauncherTalentRespec, true);
        TriggerEnable(libHJUN_gt_HeroJunkratFragLauncherSpreadVolleyCast, true);
        TriggerEnable(libHJUN_gt_HeroJunkratHeroicAbilityCastNormalMove, true);
        TriggerEnable(libHJUN_gt_HeroJunkratHeroicAbilityExpires, true);
        TriggerEnable(libHJUN_gt_HeroJunkratRocketRideLand, true);
        TriggerEnable(libHJUN_gt_HeroJunrkatRocketRideLandEnd, true);
        TriggerEnable(libHJUN_gt_HeroJunkratRocketRideDismountOnCheerDanceTauntUsed, true);
        TriggerEnable(libHJUN_gt_HeroJunkratConcussionMineCameraLock, true);
        TriggerEnable(libHJUN_gt_HeroJunkratSteelTrapUILogic, true);
        TriggerEnable(libHJUN_gt_HeroJunkratSteelTrapRoots, true);
        TriggerEnable(libHJUN_gt_HeroJunkratSteelTrapandConcussionMineAbathurCleanup, true);
        TriggerEnable(libHJUN_gt_HeroJunkratBonzerHitsOnDeathProc, true);
        TriggerEnable(libHJUN_gt_HeroJunkratDirtyTricksterProc, true);
        TriggerEnable(libHJUN_gt_IHateWaitingHomeShieldProtectionOn, true);
        TriggerEnable(libHJUN_gt_IHateWaitingHomeShieldProtectionOff, true);
        TriggerEnable(libHJUN_gt_IHateWaitingTalentCarryBehaviorOn, true);
        TriggerEnable(libHJUN_gt_IHateWaitingTalentCarryBehaviorOff, true);
    }

}

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

    if ((libHJUN_gv_heroJunkratTriggerRegistrationVariable == 0)) {
        TriggerEnable(libHJUN_gt_HeroJunkratFragLauncherTalentRespec, false);
        TriggerEnable(libHJUN_gt_HeroJunkratFragLauncherSpreadVolleyCast, false);
        TriggerEnable(libHJUN_gt_HeroJunkratHeroicAbilityExpires, false);
        TriggerEnable(libHJUN_gt_HeroJunkratHeroicAbilityCastNormalMove, false);
        TriggerEnable(libHJUN_gt_HeroJunkratRocketRideLand, false);
        TriggerEnable(libHJUN_gt_HeroJunrkatRocketRideLandEnd, false);
        TriggerEnable(libHJUN_gt_HeroJunkratRocketRideDismountOnCheerDanceTauntUsed, false);
        TriggerEnable(libHJUN_gt_HeroJunkratConcussionMineCameraLock, false);
        TriggerEnable(libHJUN_gt_HeroJunkratSteelTrapUILogic, false);
        TriggerEnable(libHJUN_gt_HeroJunkratSteelTrapRoots, false);
        TriggerEnable(libHJUN_gt_HeroJunkratSteelTrapandConcussionMineAbathurCleanup, false);
        TriggerEnable(libHJUN_gt_HeroJunkratBonzerHitsOnDeathProc, false);
        TriggerEnable(libHJUN_gt_HeroJunkratDirtyTricksterProc, false);
        TriggerEnable(libHJUN_gt_IHateWaitingHomeShieldProtectionOn, false);
        TriggerEnable(libHJUN_gt_IHateWaitingHomeShieldProtectionOff, false);
        TriggerEnable(libHJUN_gt_IHateWaitingTalentCarryBehaviorOn, false);
        TriggerEnable(libHJUN_gt_IHateWaitingTalentCarryBehaviorOff, false);
    }

}

void libHJUN_gf_PlayerTurnMountCostsOnOffForPlayer (int lp_player, bool lp_onOff) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_onOff == true)) {
        CatalogFieldValueSet(c_gameCatalogAbil, "JunkratIHateWaitingSummonMount", "CastIntroTime", lp_player, CatalogFieldValueGet(c_gameCatalogAbil, "JunkratIHateWaitingSummonMount", "CastIntroTime[" + IntToString(0) + "]", 0));
        CatalogFieldValueSet(c_gameCatalogAbil, "JunkratIHateWaitingSummonMount", "Cost.Cooldown.TimeUse", lp_player, CatalogFieldValueGet(c_gameCatalogAbil, "JunkratIHateWaitingSummonMount", "Cost.Cooldown.TimeUse", 0));
        CatalogFieldValueSet(c_gameCatalogEffect, "JunkratIHateWaitingModifyCooldown", "Cost[" + IntToString(0) + "].CooldownTimeUse", lp_player, CatalogFieldValueGet(c_gameCatalogEffect, "JunkratIHateWaitingModifyCooldown", "Cost[" + IntToString(0) + "].CooldownTimeUse", 0));
    }
    else {
        CatalogFieldValueSet(c_gameCatalogAbil, "JunkratIHateWaitingSummonMount", "CastIntroTime", lp_player, "0");
        CatalogFieldValueSet(c_gameCatalogAbil, "JunkratIHateWaitingSummonMount", "Cost.Cooldown.TimeUse", lp_player, "0");
    }
}

// Triggers
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Junkrat- Dirty Trickster Proc
//--------------------------------------------------------------------------------------------------
bool libHJUN_gt_HeroJunkratDirtyTricksterProc_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_unit;
    int lv_player;

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

    // Conditions
    if (testConds) {
        if (!((UnitGetCooldown(lv_unit, "JunkratTotalMayhemDirtyTrickster") <= 0.0))) {
            return false;
        }

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

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

        if (!((UnitHasBehaviorWithCategoryFlag(lv_unit, c_behaviorCategoryBuffUnstoppable) == false))) {
            return false;
        }
    }

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

    UnitCreateEffectUnit(lv_unit, "JunkratTotalMayhemDirtyTricksterCastSet", lv_unit);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHJUN_gt_HeroJunkratDirtyTricksterProc_Init () {
    libHJUN_gt_HeroJunkratDirtyTricksterProc = TriggerCreate("libHJUN_gt_HeroJunkratDirtyTricksterProc_Func");
    TriggerEnable(libHJUN_gt_HeroJunkratDirtyTricksterProc, false);
    TriggerAddEventUnitBehaviorChangeFromCategory(libHJUN_gt_HeroJunkratDirtyTricksterProc, null, c_behaviorCategoryStun, c_unitBehaviorChangeCreate);
    TriggerAddEventUnitBehaviorChangeFromCategory(libHJUN_gt_HeroJunkratDirtyTricksterProc, null, c_behaviorCategoryDebuffRoot, c_unitBehaviorChangeCreate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Junkrat - Frag Launcher - Talent Respec
//--------------------------------------------------------------------------------------------------
bool libHJUN_gt_HeroJunkratFragLauncherTalentRespec_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_junkratPlayer;
    unit lv_junkratUnit;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_junkratPlayer = libGame_gf_HeroRespecsTalentsPlayer();
    lv_junkratUnit = libGame_gv_players[lv_junkratPlayer].lv_heroUnit;

    // Conditions
    if (testConds) {
        if (!((UnitGetType(lv_junkratUnit) == "HeroJunkrat"))) {
            return false;
        }
    }

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

    UnitSetPropertyFixed(libGame_gv_players[lv_junkratPlayer].lv_heroUnit, c_unitPropEnergy, 100.0);
    UnitCreateEffectUnit(lv_junkratUnit, "JunkratFragLauncherBurstFireTalentPickedModifyCooldown", lv_junkratUnit);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHJUN_gt_HeroJunkratFragLauncherTalentRespec_Init () {
    libHJUN_gt_HeroJunkratFragLauncherTalentRespec = TriggerCreate("libHJUN_gt_HeroJunkratFragLauncherTalentRespec_Func");
    TriggerEnable(libHJUN_gt_HeroJunkratFragLauncherTalentRespec, false);
    libGame_gf_HeroRespecsTalents(libHJUN_gt_HeroJunkratFragLauncherTalentRespec);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Junkrat - Frag Launcher - Spread Volley Cast
//--------------------------------------------------------------------------------------------------
bool libHJUN_gt_HeroJunkratFragLauncherSpreadVolleyCast_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_junkratUnit;
    point lv_positionOfJunkratUnit;
    int lv_junkratPlayer;
    point lv_targetPoint;
    fixed lv_distanceBetweenJunkratUnitAndTargetPoint;
    fixed lv_xOffsetForLeftMissile;
    fixed lv_xOffsetForRightMissile;
    fixed lv_yOffsetMissiles;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_junkratUnit = EventPlayerEffectUsedUnit(c_effectUnitCaster);
    lv_positionOfJunkratUnit = UnitGetPosition(lv_junkratUnit);
    lv_junkratPlayer = UnitGetOwner(EventPlayerEffectUsedUnit(c_effectUnitCaster));
    lv_targetPoint = EventPlayerEffectUsedPoint(c_effectLocationTargetPoint);
    lv_distanceBetweenJunkratUnitAndTargetPoint = DistanceBetweenPoints(lv_positionOfJunkratUnit, lv_targetPoint);

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

    lv_xOffsetForLeftMissile = (lv_distanceBetweenJunkratUnitAndTargetPoint * libHJUN_gv_heroJunkratFragLauncherSpreadVolleyXMultiplier);
    lv_xOffsetForRightMissile = (-1.0 * lv_xOffsetForLeftMissile);
    lv_yOffsetMissiles = (lv_distanceBetweenJunkratUnitAndTargetPoint * libHJUN_gv_heroJunkratFragLauncherSpreadVolleyYMultiplier);
    UnitCreateEffectPoint(lv_junkratUnit, "JunkratFragLauncherSpreadVolleyArcLaunchPersistentLeft", PointWithOffsetPolar(libNtve_gf_PointOffsetTowardsPoint(lv_targetPoint, lv_yOffsetMissiles, lv_positionOfJunkratUnit), lv_xOffsetForLeftMissile, (UnitGetFacing(lv_junkratUnit) - 90.0)));
    UnitCreateEffectPoint(lv_junkratUnit, "JunkratFragLauncherSpreadVolleyArcLaunchPersistentRight", PointWithOffsetPolar(libNtve_gf_PointOffsetTowardsPoint(lv_targetPoint, lv_yOffsetMissiles, lv_positionOfJunkratUnit), lv_xOffsetForRightMissile, (UnitGetFacing(lv_junkratUnit) - 90.0)));
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHJUN_gt_HeroJunkratFragLauncherSpreadVolleyCast_Init () {
    libHJUN_gt_HeroJunkratFragLauncherSpreadVolleyCast = TriggerCreate("libHJUN_gt_HeroJunkratFragLauncherSpreadVolleyCast_Func");
    TriggerEnable(libHJUN_gt_HeroJunkratFragLauncherSpreadVolleyCast, false);
    TriggerAddEventPlayerEffectUsed(libHJUN_gt_HeroJunkratFragLauncherSpreadVolleyCast, c_playerAny, "JunkratFragLauncherSpreadVolleyCreateDummyPersistent");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Junkrat - Steel Traps UI Initialization
//--------------------------------------------------------------------------------------------------
bool libHJUN_gt_HeroJunkratSteelTrapsUIInitialization_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_panel;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_panel = c_invalidDialogControlId;

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

    DialogControlHookup(libUIUI_gv_heroSpecificStatusContainer, c_triggerControlTypePanel, "JunkratFrame");
    lv_panel = DialogControlLastCreated();
    DialogControlHookup(lv_panel, c_triggerControlTypeUnitStatus, "UnitStatusFrame0/SteelTrap1");
    libHJUN_gv_heroJunkratSteelTrapsFrames[1] = DialogControlLastCreated();
    DialogControlHookup(lv_panel, c_triggerControlTypeUnitStatus, "UnitStatusFrame0/SteelTrap2");
    libHJUN_gv_heroJunkratSteelTrapsFrames[2] = DialogControlLastCreated();
    DialogControlHookup(lv_panel, c_triggerControlTypeUnitStatus, "UnitStatusFrame0/SteelTrap3");
    libHJUN_gv_heroJunkratSteelTrapsFrames[3] = DialogControlLastCreated();
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHJUN_gt_HeroJunkratSteelTrapsUIInitialization_Init () {
    libHJUN_gt_HeroJunkratSteelTrapsUIInitialization = TriggerCreate("libHJUN_gt_HeroJunkratSteelTrapsUIInitialization_Func");
    libCore_gf_IncludeModInitialization(libHJUN_gt_HeroJunkratSteelTrapsUIInitialization);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Junkrat - Steel Trap UI Logic
//--------------------------------------------------------------------------------------------------
bool libHJUN_gt_HeroJunkratSteelTrapUILogic_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_junkrat;
    int lv_junkratPlayer;
    int lv_arrayIterator;
    unit lv_trap;
    unitgroup lv_junkratTrackedTraps;

    // Automatic Variable Declarations
    const int auto4B46B7E5_ae = libHJUN_gv_heroJunkratMaxSteelTraps;
    const int auto4B46B7E5_ai = 1;

    // Variable Initialization
    lv_junkrat = EventPlayerEffectUsedUnit(c_effectUnitCaster);
    lv_junkratPlayer = UnitGetOwner(lv_junkrat);
    lv_trap = EventPlayerEffectUsedUnit(c_effectUnitTarget);
    lv_junkratTrackedTraps = UnitGroupEmpty();

    // Conditions
    if (testConds) {
        if (!((UnitGetType(lv_trap) == "JunkratSteelTrap"))) {
            return false;
        }

        if (!((UnitGetType(libGame_gv_players[lv_junkratPlayer].lv_heroUnit) == "HeroJunkrat"))) {
            return false;
        }
    }

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

    lv_junkratTrackedTraps = UnitGetTrackedUnitGroup(lv_junkrat, "JunkratSteelTrapUnitTracker");
    lv_arrayIterator = 1;
    for ( ; ( (auto4B46B7E5_ai >= 0 && lv_arrayIterator <= auto4B46B7E5_ae) || (auto4B46B7E5_ai < 0 && lv_arrayIterator >= auto4B46B7E5_ae) ) ; lv_arrayIterator += auto4B46B7E5_ai ) {
        if ((UnitGroupHasUnit(lv_junkratTrackedTraps, libHJUN_gv_heroJunkratSteelTraps[lv_junkratPlayer][lv_arrayIterator]) == false)) {
            libHJUN_gv_heroJunkratSteelTraps[lv_junkratPlayer][lv_arrayIterator] = lv_trap;
            libNtve_gf_SetDialogItemUnit(libHJUN_gv_heroJunkratSteelTrapsFrames[lv_arrayIterator], lv_trap, libCore_gv_playerGroupFromPlayer[lv_junkratPlayer]);
            return true;
        }

    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHJUN_gt_HeroJunkratSteelTrapUILogic_Init () {
    libHJUN_gt_HeroJunkratSteelTrapUILogic = TriggerCreate("libHJUN_gt_HeroJunkratSteelTrapUILogic_Func");
    TriggerEnable(libHJUN_gt_HeroJunkratSteelTrapUILogic, false);
    TriggerAddEventPlayerEffectUsed(libHJUN_gt_HeroJunkratSteelTrapUILogic, c_playerAny, "JunkratSteelTrapAddTrackedUnit");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Junkrat - Steel Trap Roots
//--------------------------------------------------------------------------------------------------
bool libHJUN_gt_HeroJunkratSteelTrapRoots_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_itTrap;
    unit lv_trap;
    int lv_junkratPlayer;

    // Automatic Variable Declarations
    const int auto93718D05_ae = libHJUN_gv_heroJunkratMaxSteelTraps;
    const int auto93718D05_ai = 1;

    // Variable Initialization
    lv_trap = EventPlayerEffectUsedUnit(c_effectUnitSource);
    lv_junkratPlayer = UnitGetOwner(lv_trap);

    // Conditions
    if (testConds) {
        if (!((UnitGetType(lv_trap) == "JunkratSteelTrap"))) {
            return false;
        }

        if (!((UnitGetType(libGame_gv_players[lv_junkratPlayer].lv_heroUnit) == "HeroJunkrat"))) {
            return false;
        }
    }

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

    lv_junkratPlayer = UnitGetOwner(lv_trap);
    lv_itTrap = 1;
    for ( ; ( (auto93718D05_ai >= 0 && lv_itTrap <= auto93718D05_ae) || (auto93718D05_ai < 0 && lv_itTrap >= auto93718D05_ae) ) ; lv_itTrap += auto93718D05_ai ) {
        if ((libHJUN_gv_heroJunkratSteelTraps[lv_junkratPlayer][lv_itTrap] == lv_trap)) {
            libHJUN_gv_heroJunkratSteelTraps[lv_junkratPlayer][lv_itTrap] = null;
            DialogControlHookup(libHJUN_gv_heroJunkratSteelTrapsFrames[lv_itTrap], c_triggerControlTypeImage, "SteelTrapActiveFrame");
            DialogControlSendAnimationEvent(DialogControlLastCreated(), libCore_gv_playerGroupFromPlayer[lv_junkratPlayer], "PulseAnim");
            break;
        }

    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHJUN_gt_HeroJunkratSteelTrapRoots_Init () {
    libHJUN_gt_HeroJunkratSteelTrapRoots = TriggerCreate("libHJUN_gt_HeroJunkratSteelTrapRoots_Func");
    TriggerEnable(libHJUN_gt_HeroJunkratSteelTrapRoots, false);
    TriggerAddEventPlayerEffectUsed(libHJUN_gt_HeroJunkratSteelTrapRoots, c_playerAny, "JunkratSteelTrapKillOldTrapSource");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Junkrat - Steel Trap and Concussion Mine Abathur Cleanup
//--------------------------------------------------------------------------------------------------
bool libHJUN_gt_HeroJunkratSteelTrapandConcussionMineAbathurCleanup_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_triggeringUnit;
    unit lv_createdUnit;
    int lv_ownerOfTriggeringUnit;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_triggeringUnit = EventUnit();
    lv_createdUnit = EventUnitCreatedUnit();
    lv_ownerOfTriggeringUnit = UnitGetOwner(lv_triggeringUnit);

    // Conditions
    if (testConds) {
        if (!((libGame_gv_players[lv_ownerOfTriggeringUnit].lv_heroData.lv_heroCatalogLink == "Abathur"))) {
            return false;
        }

        if (!(((UnitGetType(lv_createdUnit) == "JunkratConcussionMine") || (UnitGetType(lv_createdUnit) == "JunkratSteelTrap")))) {
            return false;
        }
    }

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

    UnitBehaviorAdd(lv_createdUnit, "AbathurUltimateEvolutionCleanupTarget", libGame_gv_players[lv_ownerOfTriggeringUnit].lv_activeVehicle, 1);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHJUN_gt_HeroJunkratSteelTrapandConcussionMineAbathurCleanup_Init () {
    libHJUN_gt_HeroJunkratSteelTrapandConcussionMineAbathurCleanup = TriggerCreate("libHJUN_gt_HeroJunkratSteelTrapandConcussionMineAbathurCleanup_Func");
    TriggerEnable(libHJUN_gt_HeroJunkratSteelTrapandConcussionMineAbathurCleanup, false);
    TriggerAddEventUnitCreated(libHJUN_gt_HeroJunkratSteelTrapandConcussionMineAbathurCleanup, null, "JunkratSteelTrap", null);
    TriggerAddEventUnitCreated(libHJUN_gt_HeroJunkratSteelTrapandConcussionMineAbathurCleanup, null, "JunkratConcussionMine", null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Junkrat - Concussion Mine Camera Lock
//--------------------------------------------------------------------------------------------------
bool libHJUN_gt_HeroJunkratConcussionMineCameraLock_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libGame_gf_PlayerHeroDisplacementCameraLock(EventUnit(), EventUnitBehavior());
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHJUN_gt_HeroJunkratConcussionMineCameraLock_Init () {
    libHJUN_gt_HeroJunkratConcussionMineCameraLock = TriggerCreate("libHJUN_gt_HeroJunkratConcussionMineCameraLock_Func");
    TriggerEnable(libHJUN_gt_HeroJunkratConcussionMineCameraLock, false);
    TriggerAddEventUnitBehaviorChange(libHJUN_gt_HeroJunkratConcussionMineCameraLock, null, "JunkratConcussionMineLaunchTarget", c_unitBehaviorChangeActivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Junkrat- Bonzer Hits On Death Proc
//--------------------------------------------------------------------------------------------------
bool libHJUN_gt_HeroJunkratBonzerHitsOnDeathProc_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_i;
    unit lv_killedUnit;
    int lv_killingPlayer;
    unit[libCore_gv_bALMaxPlayersOnATeam + 1] lv_unit;

    // Automatic Variable Declarations
    const int auto067C6032_ae = 4;
    const int auto067C6032_ai = 1;

    // Variable Initialization
    lv_killedUnit = libGame_gf_HeroParticipatedInTakedownKilledHero();
    lv_killingPlayer = libGame_gf_HeroParticipatedInTakedownKillingPlayer();

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

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

        if (!((UnitHasBehavior2(lv_killedUnit, "JunkratBonzerHitsQuestKillBonusBehavior") == true))) {
            return false;
        }
    }

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

    lv_i = 0;
    for ( ; ( (auto067C6032_ai >= 0 && lv_i <= auto067C6032_ae) || (auto067C6032_ai < 0 && lv_i >= auto067C6032_ae) ) ; lv_i += auto067C6032_ai ) {
        lv_unit[lv_i] = UnitBehaviorEffectUnit(lv_killedUnit, "JunkratBonzerHitsQuestKillBonusBehavior", c_effectUnitCaster, lv_i);
        if ((UnitGetOwner(lv_unit[lv_i]) == lv_killingPlayer)) {
            UnitCreateEffectUnit(lv_unit[lv_i], "JunkratConcussionMineBonzerHitsHeroKillModifyTokenCount", lv_unit[lv_i]);
        }

    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHJUN_gt_HeroJunkratBonzerHitsOnDeathProc_Init () {
    libHJUN_gt_HeroJunkratBonzerHitsOnDeathProc = TriggerCreate("libHJUN_gt_HeroJunkratBonzerHitsOnDeathProc_Func");
    TriggerEnable(libHJUN_gt_HeroJunkratBonzerHitsOnDeathProc, false);
    libGame_gf_HeroParticipatedInTakedown(libHJUN_gt_HeroJunkratBonzerHitsOnDeathProc);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Junkrat - Heroic Ability - Cast (Normal Move)
//--------------------------------------------------------------------------------------------------
bool libHJUN_gt_HeroJunkratHeroicAbilityCastNormalMove_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_junkrat;
    int lv_player;
    unit lv_controllerUnit;
    bool lv_ripTireMoveEnable;

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

    // Conditions
    if (testConds) {
        if (!(((UnitGetType(lv_controllerUnit) == "JunkratRocketRideTrackerUnit") || (UnitGetType(lv_controllerUnit) == "JunkratRIPTire")))) {
            return false;
        }
    }

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

    UnitSelect(lv_controllerUnit, lv_player, true);
    if ((libAIAI_gf_HeroAIIsAIEnabledForPlayer(lv_player) == true)) {
        UnitCreateAIThinkTree(lv_controllerUnit);
    }

    libGame_gv_players[lv_player].lv_cameraPlayerUnitGroupToFocusOn = libNtve_gf_ConvertUnitToUnitGroup(lv_controllerUnit);
    libGame_gf_CameraUpdateCameraForPlayer(lv_player);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHJUN_gt_HeroJunkratHeroicAbilityCastNormalMove_Init () {
    libHJUN_gt_HeroJunkratHeroicAbilityCastNormalMove = TriggerCreate("libHJUN_gt_HeroJunkratHeroicAbilityCastNormalMove_Func");
    TriggerEnable(libHJUN_gt_HeroJunkratHeroicAbilityCastNormalMove, false);
    TriggerAddEventUnitCreated(libHJUN_gt_HeroJunkratHeroicAbilityCastNormalMove, null, "JunkratRocketRide", null);
    TriggerAddEventUnitCreated(libHJUN_gt_HeroJunkratHeroicAbilityCastNormalMove, null, "JunkratRIPTire", null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Junkrat - Heroic Ability - Expires
//--------------------------------------------------------------------------------------------------
bool libHJUN_gt_HeroJunkratHeroicAbilityExpires_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_player;

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

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

    libGame_gv_players[lv_player].lv_cameraPlayerUnitGroupToFocusOn = libGame_gv_players[lv_player].lv_heroUnitGroup;
    libGame_gf_CameraUpdateCameraForPlayer(lv_player);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHJUN_gt_HeroJunkratHeroicAbilityExpires_Init () {
    libHJUN_gt_HeroJunkratHeroicAbilityExpires = TriggerCreate("libHJUN_gt_HeroJunkratHeroicAbilityExpires_Func");
    TriggerEnable(libHJUN_gt_HeroJunkratHeroicAbilityExpires, false);
    TriggerAddEventPlayerEffectUsed(libHJUN_gt_HeroJunkratHeroicAbilityExpires, c_playerAny, "JunkratHeroicAbilityUnitDiesDummy");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Junkrat - Rocket Ride - Dismount On Cheer Dance Taunt Used
//--------------------------------------------------------------------------------------------------
bool libHJUN_gt_HeroJunkratRocketRideDismountOnCheerDanceTauntUsed_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_triggeringUnit;

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

    // Conditions
    if (testConds) {
        if (!((UnitHasBehavior2(lv_triggeringUnit, "JunkratRocketRideMountSpeedBoost") == true))) {
            return false;
        }
    }

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

    UnitCreateEffectUnit(lv_triggeringUnit, "DismountCasterSet", lv_triggeringUnit);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHJUN_gt_HeroJunkratRocketRideDismountOnCheerDanceTauntUsed_Init () {
    libHJUN_gt_HeroJunkratRocketRideDismountOnCheerDanceTauntUsed = TriggerCreate("libHJUN_gt_HeroJunkratRocketRideDismountOnCheerDanceTauntUsed_Func");
    TriggerEnable(libHJUN_gt_HeroJunkratRocketRideDismountOnCheerDanceTauntUsed, false);
    TriggerAddEventUnitAbility(libHJUN_gt_HeroJunkratRocketRideDismountOnCheerDanceTauntUsed, null, AbilityCommand("HoldFire", 3), c_unitAbilStageExecute, false);
    TriggerAddEventUnitAbility(libHJUN_gt_HeroJunkratRocketRideDismountOnCheerDanceTauntUsed, null, AbilityCommand("HoldFire", 4), c_unitAbilStageExecute, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Junkrat - Rocket Ride - Land
//--------------------------------------------------------------------------------------------------
bool libHJUN_gt_HeroJunkratRocketRideLand_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_junkratUnit;
    int lv_junkratPlayer;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_junkratUnit = EventUnit();
    lv_junkratPlayer = UnitGetOwner(EventUnit());

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

    libUIUI_gf_FullscreenOverlayAddItemForPlayer(lv_junkratPlayer, libUIUI_ge_FullscreenOverlayPriorities_Death, "Cutscenes\\GameUI_JunkratRespawnOverlay.StormCutscene", "Dead");
    Wait(1.0, c_timeGame);
    UnitCreateEffectUnit(lv_junkratUnit, "JunkratRocketRideHearthstone", lv_junkratUnit);
    UnitSetFacing(lv_junkratUnit, PointGetFacing(PlayerStartLocation(lv_junkratPlayer)), 0.0);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHJUN_gt_HeroJunkratRocketRideLand_Init () {
    libHJUN_gt_HeroJunkratRocketRideLand = TriggerCreate("libHJUN_gt_HeroJunkratRocketRideLand_Func");
    TriggerEnable(libHJUN_gt_HeroJunkratRocketRideLand, false);
    TriggerAddEventUnitBehaviorChange(libHJUN_gt_HeroJunkratRocketRideLand, null, "JunkratRocketRidePostRideBehavior", c_unitBehaviorChangeActivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Junrkat - Rocket Ride - Land End
//--------------------------------------------------------------------------------------------------
bool libHJUN_gt_HeroJunrkatRocketRideLandEnd_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_junkratUnit;
    int lv_junkratPlayer;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_junkratUnit = EventUnit();
    lv_junkratPlayer = UnitGetOwner(EventUnit());

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

    libUIUI_gf_FullscreenOverlayRemoveItemFromQueueForPlayer(UnitGetOwner(libGame_gv_players[lv_junkratPlayer].lv_heroUnit), "Cutscenes\\GameUI_JunkratRespawnOverlay.StormCutscene", "Dead");
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHJUN_gt_HeroJunrkatRocketRideLandEnd_Init () {
    libHJUN_gt_HeroJunrkatRocketRideLandEnd = TriggerCreate("libHJUN_gt_HeroJunrkatRocketRideLandEnd_Func");
    TriggerEnable(libHJUN_gt_HeroJunrkatRocketRideLandEnd, false);
    TriggerAddEventUnitBehaviorChange(libHJUN_gt_HeroJunrkatRocketRideLandEnd, null, "JunkratRocketRidePostRideBehavior", c_unitBehaviorChangeDeactivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: I Hate Waiting! - Home Shield Protection On
//--------------------------------------------------------------------------------------------------
bool libHJUN_gt_IHateWaitingHomeShieldProtectionOn_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_heroUnit;
    int lv_heroUnitOwner;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_heroUnit = EventUnit();
    lv_heroUnitOwner = UnitGetOwner(lv_heroUnit);

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

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

        if (!((UnitTypeTestAttribute(UnitGetType(lv_heroUnit), c_unitAttributeHeroic) == true))) {
            return false;
        }

        if (!((UnitGetType(lv_heroUnit) != "HeroAbathur"))) {
            return false;
        }

        if (!((UnitGetType(lv_heroUnit) != "SamuroMirrorImage"))) {
            return false;
        }
    }

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

    UnitCreateEffectUnit(lv_heroUnit, "JunkratIHateWaitingHallOfStormCooldownResetModifyUnit", lv_heroUnit);
    if (((libGame_gv_players[lv_heroUnitOwner].lv_heroUnit == lv_heroUnit) || (libGame_gv_players[lv_heroUnitOwner].lv_activeVehicle == lv_heroUnit))) {
        libHJUN_gf_PlayerTurnMountCostsOnOffForPlayer(lv_heroUnitOwner, false);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libHJUN_gt_IHateWaitingHomeShieldProtectionOn_Init () {
    libHJUN_gt_IHateWaitingHomeShieldProtectionOn = TriggerCreate("libHJUN_gt_IHateWaitingHomeShieldProtectionOn_Func");
    TriggerEnable(libHJUN_gt_IHateWaitingHomeShieldProtectionOn, false);
    TriggerAddEventUnitBehaviorChange(libHJUN_gt_IHateWaitingHomeShieldProtectionOn, null, "HallOfStormsProtectionBuff", c_unitBehaviorChangeActivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: I Hate Waiting! - Home Shield Protection Off
//--------------------------------------------------------------------------------------------------
bool libHJUN_gt_IHateWaitingHomeShieldProtectionOff_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_heroUnit;
    int lv_heroUnitOwner;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_heroUnit = EventUnit();
    lv_heroUnitOwner = UnitGetOwner(lv_heroUnit);

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

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

        if (!((UnitTypeTestAttribute(UnitGetType(lv_heroUnit), c_unitAttributeHeroic) == true))) {
            return false;
        }

        if (!((UnitGetType(lv_heroUnit) != "HeroAbathur"))) {
            return false;
        }

        if (!((UnitGetType(lv_heroUnit) != "SamuroMirrorImage"))) {
            return false;
        }
    }

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

    if (((libGame_gv_players[lv_heroUnitOwner].lv_heroUnit == lv_heroUnit) || (libGame_gv_players[lv_heroUnitOwner].lv_activeVehicle == lv_heroUnit))) {
        libHJUN_gf_PlayerTurnMountCostsOnOffForPlayer(lv_heroUnitOwner, true);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libHJUN_gt_IHateWaitingHomeShieldProtectionOff_Init () {
    libHJUN_gt_IHateWaitingHomeShieldProtectionOff = TriggerCreate("libHJUN_gt_IHateWaitingHomeShieldProtectionOff_Func");
    TriggerEnable(libHJUN_gt_IHateWaitingHomeShieldProtectionOff, false);
    TriggerAddEventUnitBehaviorChange(libHJUN_gt_IHateWaitingHomeShieldProtectionOff, null, "HallOfStormsProtectionBuff", c_unitBehaviorChangeDeactivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: I Hate Waiting! - Talent Carry Behavior On
//--------------------------------------------------------------------------------------------------
bool libHJUN_gt_IHateWaitingTalentCarryBehaviorOn_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_player;

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

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

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

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

    libGame_gv_players[lv_player].lv_defaultMountOverride = "JunkratIHateWaitingMountSpeedBoostBehavior";
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHJUN_gt_IHateWaitingTalentCarryBehaviorOn_Init () {
    libHJUN_gt_IHateWaitingTalentCarryBehaviorOn = TriggerCreate("libHJUN_gt_IHateWaitingTalentCarryBehaviorOn_Func");
    TriggerEnable(libHJUN_gt_IHateWaitingTalentCarryBehaviorOn, false);
    TriggerAddEventUnitBehaviorChange(libHJUN_gt_IHateWaitingTalentCarryBehaviorOn, null, "JunkratIHateWaitingCarryBehavior", c_unitBehaviorChangeCreate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: I Hate Waiting! - Talent Carry Behavior Off
//--------------------------------------------------------------------------------------------------
bool libHJUN_gt_IHateWaitingTalentCarryBehaviorOff_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_player;

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

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

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

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

    libGame_gv_players[lv_player].lv_defaultMountOverride = null;
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHJUN_gt_IHateWaitingTalentCarryBehaviorOff_Init () {
    libHJUN_gt_IHateWaitingTalentCarryBehaviorOff = TriggerCreate("libHJUN_gt_IHateWaitingTalentCarryBehaviorOff_Func");
    TriggerEnable(libHJUN_gt_IHateWaitingTalentCarryBehaviorOff, false);
    TriggerAddEventUnitBehaviorChange(libHJUN_gt_IHateWaitingTalentCarryBehaviorOff, null, "JunkratIHateWaitingCarryBehavior", c_unitBehaviorChangeDestroy);
}

void libHJUN_InitTriggers () {
    libHJUN_gt_HeroJunkratDirtyTricksterProc_Init();
    libHJUN_gt_HeroJunkratFragLauncherTalentRespec_Init();
    libHJUN_gt_HeroJunkratFragLauncherSpreadVolleyCast_Init();
    libHJUN_gt_HeroJunkratSteelTrapsUIInitialization_Init();
    libHJUN_gt_HeroJunkratSteelTrapUILogic_Init();
    libHJUN_gt_HeroJunkratSteelTrapRoots_Init();
    libHJUN_gt_HeroJunkratSteelTrapandConcussionMineAbathurCleanup_Init();
    libHJUN_gt_HeroJunkratConcussionMineCameraLock_Init();
    libHJUN_gt_HeroJunkratBonzerHitsOnDeathProc_Init();
    libHJUN_gt_HeroJunkratHeroicAbilityCastNormalMove_Init();
    libHJUN_gt_HeroJunkratHeroicAbilityExpires_Init();
    libHJUN_gt_HeroJunkratRocketRideDismountOnCheerDanceTauntUsed_Init();
    libHJUN_gt_HeroJunkratRocketRideLand_Init();
    libHJUN_gt_HeroJunrkatRocketRideLandEnd_Init();
    libHJUN_gt_IHateWaitingHomeShieldProtectionOn_Init();
    libHJUN_gt_IHateWaitingHomeShieldProtectionOff_Init();
    libHJUN_gt_IHateWaitingTalentCarryBehaviorOn_Init();
    libHJUN_gt_IHateWaitingTalentCarryBehaviorOff_Init();
}

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

void libHJUN_InitLib () {
    if (libHJUN_InitLib_completed) {
        return;
    }

    libHJUN_InitLib_completed = true;

    libHJUN_InitLibraries();
    libHJUN_InitVariables();
    libHJUN_InitTriggers();
}