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

}