mods/heromods/hanzo.stormmod/base.stormdata/libhhan.galaxy

libhhan.galaxy
include "TriggerLibs/NativeLib"
include "TriggerLibs/HeroesLib"
include "TriggerLibs/GameLib"

include "LibHHAN_h"

//--------------------------------------------------------------------------------------------------
// Library: Hanzo
//--------------------------------------------------------------------------------------------------
// External Library Initialization
void libHHAN_InitLibraries () {
    libNtve_InitVariables();
    libCore_InitVariables();
    libGame_InitVariables();
}

// Variable Initialization
bool libHHAN_InitVariables_completed = false;

void libHHAN_InitVariables () {
    int init_i;

    if (libHHAN_InitVariables_completed) {
        return;
    }

    libHHAN_InitVariables_completed = true;

    libHHAN_gv_heroHanzoScatterArrowImpactCountThreshold = 3;
    for (init_i = 0; init_i <= libCore_gv_bALMaxPlayers; init_i += 1) {
        libHHAN_gv_heroHanzoStormBowBaseRangeForPlayer[init_i] = libHHAN_gv_heroHanzoStormBowDefaultBaseRange;
    }
    for (init_i = 0; init_i <= libCore_gv_bALMaxPlayers; init_i += 1) {
        libHHAN_gv_heroHanzoStormBowMaximumRangeForPlayer[init_i] = libHHAN_gv_heroHanzoStormBowDefaultMaximumRange;
    }
    for (init_i = 0; init_i <= libCore_gv_bALMaxPlayers; init_i += 1) {
        libHHAN_gv_heroHanzoTargetPracticeAllEnemyHeroes[init_i] = UnitGroupEmpty();
    }
    for (init_i = 0; init_i <= libCore_gv_bALMaxPlayers; init_i += 1) {
        libHHAN_gv_heroHanzoTargetPracticeHeroesNotHit[init_i] = UnitGroupEmpty();
    }
    for (init_i = 0; init_i <= libCore_gv_bALMaxPlayers; init_i += 1) {
        libHHAN_gv_heroHanzoTargetPracticeEnemyHeroesHitOnce[init_i] = UnitGroupEmpty();
    }
    for (init_i = 0; init_i <= libCore_gv_bALMaxPlayers; init_i += 1) {
        libHHAN_gv_heroHanzoTargetPracticeEnemyHeroesHitTwice[init_i] = UnitGroupEmpty();
    }
    for (init_i = 0; init_i <= libCore_gv_bALMaxPlayers; init_i += 1) {
        libHHAN_gv_heroHanzoTargetPracticeEnemyHeroesHitThreeTimes[init_i] = UnitGroupEmpty();
    }
    libHHAN_gv_heroHanzoTargetPracticeRewardRangeMultiplier = 1.3;
}

// Functions
void libHHAN_gf_HeroHanzoIncrementHeroCountFunction () {
    // Automatic Variable Declarations
    // Implementation
    libHHAN_gv_heroHanzoHanzoTriggerRegistrationCount0 += 1;
    if ((libHHAN_gv_heroHanzoHanzoTriggerRegistrationCount0 == 1)) {
        TriggerEnable(libHHAN_gt_HeroHanzoStormBowCharging, true);
        TriggerEnable(libHHAN_gt_HeroHanzoScatterArrowPlayImpactFX, true);
        TriggerEnable(libHHAN_gt_HeroHanzoSonicArrowUnitGainsTrackingBehavior, true);
        TriggerEnable(libHHAN_gt_HeroHanzoTargetPracticePlayerGetsRangeIncrease, true);
        TriggerEnable(libHHAN_gt_HeroHanzoTargetPracticePlayerLosesRangeIncrease, true);
        TriggerEnable(libHHAN_gt_HeroHanzoDragonstrikeSearch, true);
        TriggerEnable(libHHAN_gt_HeroHanzoTargetPracticeTalentSelected, true);
        TriggerEnable(libHHAN_gt_HeroHanzoTargetPracticePlayerRespecs, true);
        TriggerEnable(libHHAN_gt_HeroHanzoTargetPracticeHeroHitByStormBow, true);
        TriggerEnable(libHHAN_gt_HeroHanzoTargetPracticeCloneorMechSpawned, true);
        TriggerEnable(libHHAN_gt_HeroHanzoNinjaAssassinRefreshNaturalAgilityonTakedown, true);
        TriggerEnable(libHHAN_gt_HeroHanzoTargetPracticeHeroSpawned, true);
    }

}

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

    if ((libHHAN_gv_heroHanzoHanzoTriggerRegistrationCount0 == 0)) {
        TriggerEnable(libHHAN_gt_HeroHanzoStormBowCharging, false);
        TriggerEnable(libHHAN_gt_HeroHanzoScatterArrowPlayImpactFX, false);
        TriggerEnable(libHHAN_gt_HeroHanzoSonicArrowUnitGainsTrackingBehavior, false);
        TriggerEnable(libHHAN_gt_HeroHanzoTargetPracticePlayerGetsRangeIncrease, false);
        TriggerEnable(libHHAN_gt_HeroHanzoTargetPracticePlayerLosesRangeIncrease, false);
        TriggerEnable(libHHAN_gt_HeroHanzoDragonstrikeSearch, false);
        TriggerEnable(libHHAN_gt_HeroHanzoTargetPracticeTalentSelected, false);
        TriggerEnable(libHHAN_gt_HeroHanzoTargetPracticePlayerRespecs, false);
        TriggerEnable(libHHAN_gt_HeroHanzoTargetPracticeHeroHitByStormBow, false);
        TriggerEnable(libHHAN_gt_HeroHanzoTargetPracticeCloneorMechSpawned, false);
        TriggerEnable(libHHAN_gt_HeroHanzoNinjaAssassinRefreshNaturalAgilityonTakedown, false);
        TriggerEnable(libHHAN_gt_HeroHanzoTargetPracticeHeroSpawned, false);
    }

}

void libHHAN_gf_HeroHanzoTargetPracticeConfigureQuestForPlayer (int lp_player) {
    // Variable Declarations
    unit lv_hanzoUnit;
    int lv_enemyTeamNumber;
    int lv_currentPlayerNumber;
    unit lv_currentUnit;

    // Automatic Variable Declarations
    playergroup autoB5955E8D_g;
    string autoF956DA24_val;
    unitgroup auto739E3D99_g;
    int auto739E3D99_u;
    unit auto739E3D99_var;
    unitgroup auto48332F8C_g;
    int auto48332F8C_u;

    // Variable Initialization
    lv_hanzoUnit = libGame_gv_players[lp_player].lv_heroUnit;
    lv_enemyTeamNumber = libGame_gf_EnemyTeamNumberOfPlayer(lp_player);

    // Implementation
    autoB5955E8D_g = libGame_gv_teams[lv_enemyTeamNumber].lv_teamPlayerGroup;
    lv_currentPlayerNumber = -1;
    while (true) {
        	lv_currentPlayerNumber = PlayerGroupNextPlayer(autoB5955E8D_g, lv_currentPlayerNumber);
        	if (lv_currentPlayerNumber<0) { break; }
        	if ((lv_currentPlayerNumber > 0) && (lv_currentPlayerNumber <= libCore_gv_bALMaxPlayers) && (UnitGetType(libGame_gv_players[lv_currentPlayerNumber].lv_heroUnit) != "HeroGall")) {
            autoF956DA24_val = UnitGetType(libGame_gv_players[lv_currentPlayerNumber].lv_heroUnit);
            if (autoF956DA24_val == "HeroLostVikingsController") {
                auto739E3D99_g = libGame_gv_players[lv_currentPlayerNumber].lv_heroUnitGroup;
                auto739E3D99_u = UnitGroupCount(auto739E3D99_g, c_unitCountAll);
                for (;; auto739E3D99_u -= 1) {
                    auto739E3D99_var = UnitGroupUnitFromEnd(auto739E3D99_g, auto739E3D99_u);
                    if (auto739E3D99_var == null) { break; }
                    if ((UnitGetType(auto739E3D99_var) != "HeroLostVikingsController")) {
                        UnitBehaviorRemove(auto739E3D99_var, "HanzoTargetPracticeTargetTokenCounter", 1);
                        UnitBehaviorAdd(auto739E3D99_var, "HanzoTargetPracticeTargetTokenCounter", lv_hanzoUnit, 1);
                        UnitBehaviorAdd(auto739E3D99_var, "HanzoTargetPracticeOwnershipDummy", lv_hanzoUnit, 1);
                        UnitGroupAdd(libHHAN_gv_heroHanzoTargetPracticeAllEnemyHeroes[lp_player], auto739E3D99_var);
                    }

                }
            }
            else if (autoF956DA24_val == "HeroDVaPilot") {
                auto48332F8C_g = libGame_gv_players[lv_currentPlayerNumber].lv_heroUnitGroup;
                auto48332F8C_u = UnitGroupCount(auto48332F8C_g, c_unitCountAll);
                for (;; auto48332F8C_u -= 1) {
                    lv_currentUnit = UnitGroupUnitFromEnd(auto48332F8C_g, auto48332F8C_u);
                    if (lv_currentUnit == null) { break; }
                    UnitBehaviorRemove(lv_currentUnit, "HanzoTargetPracticeTargetTokenCounter", 1);
                    UnitBehaviorAdd(lv_currentUnit, "HanzoTargetPracticeTargetTokenCounter", lv_hanzoUnit, 1);
                    UnitBehaviorAdd(lv_currentUnit, "HanzoTargetPracticeOwnershipDummy", lv_hanzoUnit, 1);
                }
                UnitGroupAdd(libHHAN_gv_heroHanzoTargetPracticeAllEnemyHeroes[lp_player], libGame_gv_players[lv_currentPlayerNumber].lv_heroUnit);
            }
            else {
                UnitBehaviorRemove(libGame_gv_players[lv_currentPlayerNumber].lv_heroUnit, "HanzoTargetPracticeTargetTokenCounter", 1);
                UnitBehaviorAdd(libGame_gv_players[lv_currentPlayerNumber].lv_heroUnit, "HanzoTargetPracticeTargetTokenCounter", lv_hanzoUnit, 1);
                UnitBehaviorAdd(libGame_gv_players[lv_currentPlayerNumber].lv_heroUnit, "HanzoTargetPracticeOwnershipDummy", lv_hanzoUnit, 1);
                UnitGroupAdd(libHHAN_gv_heroHanzoTargetPracticeAllEnemyHeroes[lp_player], libGame_gv_players[lv_currentPlayerNumber].lv_heroUnit);
            }
        }

    }
    UnitGroupAddUnitGroup(libHHAN_gv_heroHanzoTargetPracticeHeroesNotHit[lp_player], libHHAN_gv_heroHanzoTargetPracticeAllEnemyHeroes[lp_player]);
    UnitSetTokenCount(lv_hanzoUnit, "HanzoTargetPracticeTargetsHitOnceTokenCounter", 0.0, lv_hanzoUnit);
    UnitSetTokenCount(lv_hanzoUnit, "HanzoTargetPracticeTokenCounter", 0.0, lv_hanzoUnit);
    UnitSetTokenCount(lv_hanzoUnit, "HanzoTargetPracticeDummyProgressTokenCounter", 0.0, lv_hanzoUnit);
    CatalogFieldValueSet(c_gameCatalogBehavior, "HanzoTargetPracticeTokenCounter", "Max", lp_player, IntToString(UnitGroupCount(libHHAN_gv_heroHanzoTargetPracticeAllEnemyHeroes[lp_player], c_unitCountAll)));
    CatalogFieldValueSet(c_gameCatalogBehavior, "HanzoTargetPracticeTargetsHitOnceTokenCounter", "Max", lp_player, IntToString(UnitGroupCount(libHHAN_gv_heroHanzoTargetPracticeAllEnemyHeroes[lp_player], c_unitCountAll)));
}

void libHHAN_gf_HeroHanzoTargetPracticeResetQuestProgress (int lp_player) {
    // Automatic Variable Declarations
    // Implementation
    UnitGroupClear(libHHAN_gv_heroHanzoTargetPracticeAllEnemyHeroes[lp_player]);
    UnitGroupClear(libHHAN_gv_heroHanzoTargetPracticeHeroesNotHit[lp_player]);
    UnitGroupClear(libHHAN_gv_heroHanzoTargetPracticeEnemyHeroesHitOnce[lp_player]);
    UnitGroupClear(libHHAN_gv_heroHanzoTargetPracticeEnemyHeroesHitTwice[lp_player]);
    UnitGroupClear(libHHAN_gv_heroHanzoTargetPracticeEnemyHeroesHitThreeTimes[lp_player]);
    UnitBehaviorRemove(libGame_gv_players[lp_player].lv_heroUnit, "HanzoTargetPracticeDamageIncrease", 1);
    UnitBehaviorRemove(libGame_gv_players[lp_player].lv_heroUnit, "HanzoTargetPracticeRangeIncrease", 1);
}

// Triggers
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Hanzo - Dragonstrike - Search
//--------------------------------------------------------------------------------------------------
bool libHHAN_gt_HeroHanzoDragonstrikeSearch_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_controllerUnit;
    int lv_playerNumber;
    fixed lv_searchLength;
    fixed lv_missileSpeed;
    fixed lv_missileDistancePerLoop;
    fixed lv_searchStartDistance;
    fixed lv_searchEndDistance;
    fixed lv_currentEstimatedMissileDistance;
    fixed lv_currentSearchStartDistance;
    fixed lv_currentSearchEndDistance;
    fixed lv_currentSearchLength;
    fixed lv_currentSearchOffset;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_controllerUnit = EventUnitCreatedUnit();
    lv_playerNumber = UnitGetOwner(lv_controllerUnit);
    lv_searchLength = CatalogFieldValueGetAsFixed(c_gameCatalogEffect, "HanzoDragonstrikeSearchArea", "AreaArray[" + IntToString(0) + "].RectangleHeight", c_playerAny);
    lv_missileSpeed = CatalogFieldValueGetAsFixed(c_gameCatalogMover, "HanzoDragonstrikeDragonMover", "MotionPhases[" + IntToString(0) + "].Speed", c_playerAny);
    lv_missileDistancePerLoop = (lv_missileSpeed / 16.0);
    lv_searchStartDistance = 8.0;
    lv_searchEndDistance = 44.0;

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

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

    while ((lv_currentSearchEndDistance < lv_searchEndDistance)) {
        Wait(0.0625, c_timeGame);
        lv_currentSearchStartDistance = lv_currentEstimatedMissileDistance;
        lv_currentSearchEndDistance = (lv_currentSearchStartDistance - lv_searchLength);
        lv_currentSearchStartDistance = libNtve_gf_ArithmeticRealClamp(lv_currentSearchStartDistance, lv_searchStartDistance, lv_searchEndDistance);
        lv_currentSearchEndDistance = libNtve_gf_ArithmeticRealClamp(lv_currentSearchEndDistance, lv_searchStartDistance, lv_searchEndDistance);
        lv_currentSearchLength = (lv_currentSearchStartDistance - lv_currentSearchEndDistance);
        CatalogFieldValueSetFixed(c_gameCatalogEffect, "HanzoDragonstrikeSearchArea", "AreaArray[" + IntToString(0) + "].RectangleHeight", lv_playerNumber, lv_currentSearchLength);
        CatalogFieldValueSetFixed(c_gameCatalogEffect, "HanzoDragonstrikeSearchArea", "AreaArray[" + IntToString(1) + "].RectangleHeight", lv_playerNumber, lv_currentSearchLength);
        lv_currentSearchOffset = lv_currentSearchStartDistance;
        lv_currentSearchOffset -= (lv_currentSearchLength / 2.0);
        CatalogFieldValueSet(c_gameCatalogEffect, "HanzoDragonstrikeSearchArea", "AreaRelativeOffset", lv_playerNumber, ("0," + FixedToString(lv_currentSearchOffset, c_fixedPrecisionAny)));
        lv_currentEstimatedMissileDistance += lv_missileDistancePerLoop;
        if ((lv_currentSearchLength > 0.0)) {
            CatalogFieldValueSetFixed(c_gameCatalogEffect, "HanzoDragonstrikeSearchArea", "Chance", EventPlayer(), 1.0);
        }
        else {
            CatalogFieldValueSetFixed(c_gameCatalogEffect, "HanzoDragonstrikeSearchArea", "Chance", EventPlayer(), 0.0);
        }
    }
    UnitKill(lv_controllerUnit);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHHAN_gt_HeroHanzoDragonstrikeSearch_Init () {
    libHHAN_gt_HeroHanzoDragonstrikeSearch = TriggerCreate("libHHAN_gt_HeroHanzoDragonstrikeSearch_Func");
    TriggerEnable(libHHAN_gt_HeroHanzoDragonstrikeSearch, false);
    TriggerAddEventUnitCreated(libHHAN_gt_HeroHanzoDragonstrikeSearch, null, null, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Hanzo - Scatter Arrow - Play Impact FX
//--------------------------------------------------------------------------------------------------
bool libHHAN_gt_HeroHanzoScatterArrowPlayImpactFX_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_target;
    unit lv_caster;
    fixed lv_tokenCount;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_target = EventPlayerEffectUsedUnit(c_effectUnitTarget);
    lv_caster = EventPlayerEffectUsedUnit(c_effectUnitCaster);
    lv_tokenCount = UnitGetTokenCount(lv_target, "HanzoScatterArrowSimultaneousImpactCounter");

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

    if ((lv_tokenCount >= libHHAN_gv_heroHanzoScatterArrowImpactCountThreshold)) {
        UnitCreateEffectUnit(lv_caster, "HanzoScatterArrowMultiHitImpactFXDummy", lv_target);
    }
    else {
        UnitCreateEffectUnit(lv_caster, "HanzoScatterArrowImpactFXDummy", lv_target);
    }
    UnitBehaviorRemove(lv_target, "HanzoScatterArrowSimultaneousImpactCounter", 1);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHHAN_gt_HeroHanzoScatterArrowPlayImpactFX_Init () {
    libHHAN_gt_HeroHanzoScatterArrowPlayImpactFX = TriggerCreate("libHHAN_gt_HeroHanzoScatterArrowPlayImpactFX_Func");
    TriggerEnable(libHHAN_gt_HeroHanzoScatterArrowPlayImpactFX, false);
    TriggerAddEventPlayerEffectUsed(libHHAN_gt_HeroHanzoScatterArrowPlayImpactFX, c_playerAny, "HanzoScatterArrowImpactCounterBehaviorAppliedDummy");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Hanzo - Sonic Arrow - Unit Gains Tracking Behavior
//--------------------------------------------------------------------------------------------------
bool libHHAN_gt_HeroHanzoSonicArrowUnitGainsTrackingBehavior_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_trackedUnit;
    unit lv_trackerUnit;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_trackedUnit = EventUnit();
    lv_trackerUnit = UnitBehaviorEffectUnit(lv_trackedUnit, "HanzoSonicArrowFollowTarget", c_effectUnitSource, 0);

    // Conditions
    if (testConds) {
        if (!((UnitIsValid(lv_trackerUnit) == true))) {
            return false;
        }

        if (!((UnitGetType(lv_trackerUnit) == "HanzoSonicArrowTracker"))) {
            return false;
        }
    }

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

    while ((UnitIsValid(lv_trackerUnit) == true) && (UnitIsValid(lv_trackedUnit) == true) && (UnitHasBehavior2(lv_trackedUnit, "HanzoSonicArrowFollowTarget") == true)) {
        if ((DistanceBetweenPoints(UnitGetPosition(lv_trackedUnit), UnitGetPosition(lv_trackerUnit)) < 4.0)) {
            UnitSetPosition(lv_trackerUnit, UnitGetPosition(lv_trackedUnit), true);
        }
        else {
            UnitSetPosition(lv_trackerUnit, UnitGetPosition(lv_trackedUnit), false);
        }
        Wait(0.0625, c_timeGame);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHHAN_gt_HeroHanzoSonicArrowUnitGainsTrackingBehavior_Init () {
    libHHAN_gt_HeroHanzoSonicArrowUnitGainsTrackingBehavior = TriggerCreate("libHHAN_gt_HeroHanzoSonicArrowUnitGainsTrackingBehavior_Func");
    TriggerEnable(libHHAN_gt_HeroHanzoSonicArrowUnitGainsTrackingBehavior, false);
    TriggerAddEventUnitBehaviorChange(libHHAN_gt_HeroHanzoSonicArrowUnitGainsTrackingBehavior, null, "HanzoSonicArrowFollowTarget", c_unitBehaviorChangeCreate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Hanzo - Storm Bow - Charging
//--------------------------------------------------------------------------------------------------
bool libHHAN_gt_HeroHanzoStormBowCharging_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_unit;
    int lv_player;
    fixed lv_currentOffset;
    fixed lv_extraRange;
    fixed lv_chargingBehaviorDuration;
    fixed lv_numberofGrowthLoops;
    fixed lv_offsetPerLoop;
    actor lv_guide;
    bool lv_isScaling;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_unit = EventUnit();
    lv_player = UnitGetOwner(lv_unit);
    lv_currentOffset = libHHAN_gv_heroHanzoStormBowBaseRangeForPlayer[lv_player];
    lv_extraRange = (libHHAN_gv_heroHanzoStormBowMaximumRangeForPlayer[lv_player] - libHHAN_gv_heroHanzoStormBowBaseRangeForPlayer[lv_player]);
    lv_chargingBehaviorDuration = StringToFixed(CatalogFieldValueGet(c_gameCatalogBehavior, "HanzoStormBowCharging", "Duration", lv_player));
    lv_numberofGrowthLoops = ((lv_chargingBehaviorDuration / 0.0625) + 1.0);
    lv_offsetPerLoop = (lv_extraRange / lv_numberofGrowthLoops);
    lv_guide = ActorFromScope(ActorScopeFrom("::Cursor"), "HanzoStormBowGuide");

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

    CatalogFieldValueModifyFixed(c_gameCatalogEffect, "HanzoStormBowLaunchMissile", "ImpactLocation.ProjectionDistanceScale", lv_player, lv_currentOffset, c_upgradeOperationSet);
    while ((UnitHasBehavior2(lv_unit, "HanzoStormBowCharging") == true)) {
        if ((UnitHasBehaviorWithCategoryFlag(lv_unit, c_behaviorCategoryTimeStop) == false)) {
            lv_currentOffset += lv_offsetPerLoop;
            CatalogFieldValueModifyFixed(c_gameCatalogEffect, "HanzoStormBowLaunchMissile", "ImpactLocation.ProjectionDistanceScale", lv_player, lv_currentOffset, c_upgradeOperationSet);
            libNtve_gf_SendActorMessageToUnit(lv_unit, "TimerKill StandReadyOutroDuration");
            if ((lv_isScaling == false)) {
                ActorSend(lv_guide, libNtve_gf_Signal(("StormBowScalePlayer" + IntToString(lv_player))));
                lv_isScaling = true;
            }

            ActorSend(lv_guide, libNtve_gf_Signal(("StormBowResumeScalePlayer" + IntToString(lv_player))));
        }
        else {
            if ((lv_isScaling == true)) {
                ActorSend(lv_guide, libNtve_gf_Signal(("StormBowPauseScalePlayer" + IntToString(lv_player))));
                lv_isScaling = false;
            }

        }
        Wait(0.0625, c_timeGame);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHHAN_gt_HeroHanzoStormBowCharging_Init () {
    libHHAN_gt_HeroHanzoStormBowCharging = TriggerCreate("libHHAN_gt_HeroHanzoStormBowCharging_Func");
    TriggerEnable(libHHAN_gt_HeroHanzoStormBowCharging, false);
    TriggerAddEventUnitBehaviorChange(libHHAN_gt_HeroHanzoStormBowCharging, null, "HanzoStormBowCharging", c_unitBehaviorChangeCreate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Hanzo - Target Practice - Talent Selected
//--------------------------------------------------------------------------------------------------
bool libHHAN_gt_HeroHanzoTargetPracticeTalentSelected_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_player;

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

    // Conditions
    if (testConds) {
        if (!((libGame_gf_HeroGainTalentGainedTalent() == "HanzoTargetPractice"))) {
            return false;
        }
    }

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

    libHHAN_gf_HeroHanzoTargetPracticeConfigureQuestForPlayer(lv_player);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHHAN_gt_HeroHanzoTargetPracticeTalentSelected_Init () {
    libHHAN_gt_HeroHanzoTargetPracticeTalentSelected = TriggerCreate("libHHAN_gt_HeroHanzoTargetPracticeTalentSelected_Func");
    TriggerEnable(libHHAN_gt_HeroHanzoTargetPracticeTalentSelected, false);
    libGame_gf_HeroGainTalent(libHHAN_gt_HeroHanzoTargetPracticeTalentSelected);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Hanzo - Target Practice - Hero Hit By Storm Bow
//--------------------------------------------------------------------------------------------------
bool libHHAN_gt_HeroHanzoTargetPracticeHeroHitByStormBow_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_targetUnit;
    unit lv_originalTarget;
    int lv_targetPlayer;
    unit lv_hanzoUnit;
    int lv_hanzoPlayer;

    // Automatic Variable Declarations
    unitgroup auto25C731B6_g;
    int auto25C731B6_u;
    unit auto25C731B6_var;

    // Variable Initialization
    lv_targetUnit = EventPlayerEffectUsedUnit(c_effectUnitTarget);
    lv_originalTarget = lv_targetUnit;
    lv_targetPlayer = UnitGetOwner(lv_targetUnit);
    lv_hanzoUnit = EventPlayerEffectUsedUnit(c_effectUnitCaster);
    lv_hanzoPlayer = UnitGetOwner(lv_hanzoUnit);

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

    if ((((UnitGetType(lv_targetUnit) == "SamuroMirrorImage") && (UnitGetType(libGame_gv_players[lv_targetPlayer].lv_heroUnit) == "HeroSamuro")) || ((UnitGetType(lv_targetUnit) == "HeroDVaMech") && (UnitGetType(libGame_gv_players[lv_targetPlayer].lv_heroUnit) == "HeroDVaPilot")) || ((UnitGetType(lv_targetUnit) == "NovaHoloClone") && (UnitGetType(libGame_gv_players[lv_targetPlayer].lv_heroUnit) == "HeroNova")))) {
        lv_targetUnit = libGame_gv_players[UnitGetOwner(lv_targetUnit)].lv_heroUnit;
    }

    if ((UnitGroupHasUnit(libHHAN_gv_heroHanzoTargetPracticeAllEnemyHeroes[lv_hanzoPlayer], lv_targetUnit) == true) && (UnitGroupHasUnit(libHHAN_gv_heroHanzoTargetPracticeEnemyHeroesHitThreeTimes[lv_hanzoPlayer], lv_targetUnit) == false) && (PlayerHasTalent(lv_hanzoPlayer, "HanzoTargetPractice") == true)) {
    }
    else {
        return true;
    }
    if (((UnitGetType(lv_targetUnit) == "HeroDVaPilot") || (UnitGetType(lv_targetUnit) == "HeroSamuro") || (UnitGetType(lv_targetUnit) == "HeroNova"))) {
        auto25C731B6_g = libGame_gv_players[lv_targetPlayer].lv_heroUnitGroup;
        auto25C731B6_u = UnitGroupCount(auto25C731B6_g, c_unitCountAll);
        for (;; auto25C731B6_u -= 1) {
            auto25C731B6_var = UnitGroupUnitFromEnd(auto25C731B6_g, auto25C731B6_u);
            if (auto25C731B6_var == null) { break; }
            UnitSetTokenCount(auto25C731B6_var, "HanzoTargetPracticeTargetTokenCounter", (UnitGetTokenCount(auto25C731B6_var, "HanzoTargetPracticeTargetTokenCounter") - 1.0), lv_hanzoUnit);
        }
    }
    else {
        UnitSetTokenCount(lv_targetUnit, "HanzoTargetPracticeTargetTokenCounter", (UnitGetTokenCount(lv_targetUnit, "HanzoTargetPracticeTargetTokenCounter") - 1.0), lv_hanzoUnit);
    }
    if ((UnitGetType(lv_originalTarget) == "NovaHoloClone")) {
        UnitSetTokenCount(lv_originalTarget, "HanzoTargetPracticeTargetTokenCounter", UnitGetTokenCount(lv_targetUnit, "HanzoTargetPracticeTargetTokenCounter"), lv_hanzoUnit);
    }

    if ((UnitGroupHasUnit(libHHAN_gv_heroHanzoTargetPracticeEnemyHeroesHitTwice[lv_hanzoPlayer], lv_targetUnit) == true)) {
        UnitGroupRemove(libHHAN_gv_heroHanzoTargetPracticeEnemyHeroesHitTwice[lv_hanzoPlayer], lv_targetUnit);
        UnitGroupAdd(libHHAN_gv_heroHanzoTargetPracticeEnemyHeroesHitThreeTimes[lv_hanzoPlayer], lv_targetUnit);
        UnitCreateEffectUnit(lv_hanzoUnit, "HanzoTargetPracticeIncrementToken", lv_targetUnit);
        UnitCreateEffectUnit(lv_hanzoUnit, "HanzoTargetPracticeIncrementDummyToken", lv_originalTarget);
    }
    else if ((UnitGroupHasUnit(libHHAN_gv_heroHanzoTargetPracticeEnemyHeroesHitOnce[lv_hanzoPlayer], lv_targetUnit) == true)) {
        UnitGroupRemove(libHHAN_gv_heroHanzoTargetPracticeEnemyHeroesHitOnce[lv_hanzoPlayer], lv_targetUnit);
        UnitGroupAdd(libHHAN_gv_heroHanzoTargetPracticeEnemyHeroesHitTwice[lv_hanzoPlayer], lv_targetUnit);
        UnitCreateEffectUnit(lv_hanzoUnit, "HanzoTargetPracticeIncrementDummyToken", lv_originalTarget);
    }
    else if (true) {
        UnitGroupRemove(libHHAN_gv_heroHanzoTargetPracticeHeroesNotHit[lv_hanzoPlayer], lv_targetUnit);
        UnitGroupAdd(libHHAN_gv_heroHanzoTargetPracticeEnemyHeroesHitOnce[lv_hanzoPlayer], lv_targetUnit);
        UnitCreateEffectUnit(lv_hanzoUnit, "HanzoTargetPracticeIncrementDummyToken", lv_originalTarget);
        UnitCreateEffectUnit(lv_hanzoUnit, "HanzoTargetPracticeTargetsHitOnceIncrementToken", lv_hanzoUnit);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHHAN_gt_HeroHanzoTargetPracticeHeroHitByStormBow_Init () {
    libHHAN_gt_HeroHanzoTargetPracticeHeroHitByStormBow = TriggerCreate("libHHAN_gt_HeroHanzoTargetPracticeHeroHitByStormBow_Func");
    TriggerEnable(libHHAN_gt_HeroHanzoTargetPracticeHeroHitByStormBow, false);
    TriggerAddEventPlayerEffectUsed(libHHAN_gt_HeroHanzoTargetPracticeHeroHitByStormBow, c_playerAny, "HanzoStormBowImpactSet");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Hanzo - Target Practice - Player Gets Range Increase
//--------------------------------------------------------------------------------------------------
bool libHHAN_gt_HeroHanzoTargetPracticePlayerGetsRangeIncrease_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);

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

    libHHAN_gv_heroHanzoStormBowMaximumRangeForPlayer[lv_player] *= libHHAN_gv_heroHanzoTargetPracticeRewardRangeMultiplier;
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHHAN_gt_HeroHanzoTargetPracticePlayerGetsRangeIncrease_Init () {
    libHHAN_gt_HeroHanzoTargetPracticePlayerGetsRangeIncrease = TriggerCreate("libHHAN_gt_HeroHanzoTargetPracticePlayerGetsRangeIncrease_Func");
    TriggerEnable(libHHAN_gt_HeroHanzoTargetPracticePlayerGetsRangeIncrease, false);
    TriggerAddEventUnitBehaviorChange(libHHAN_gt_HeroHanzoTargetPracticePlayerGetsRangeIncrease, null, "HanzoTargetPracticeRangeIncrease", c_unitBehaviorChangeCreate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Hanzo - Target Practice - Player Loses Range Increase
//--------------------------------------------------------------------------------------------------
bool libHHAN_gt_HeroHanzoTargetPracticePlayerLosesRangeIncrease_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);

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

    libHHAN_gv_heroHanzoStormBowMaximumRangeForPlayer[lv_player] = libHHAN_gv_heroHanzoStormBowDefaultMaximumRange;
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHHAN_gt_HeroHanzoTargetPracticePlayerLosesRangeIncrease_Init () {
    libHHAN_gt_HeroHanzoTargetPracticePlayerLosesRangeIncrease = TriggerCreate("libHHAN_gt_HeroHanzoTargetPracticePlayerLosesRangeIncrease_Func");
    TriggerEnable(libHHAN_gt_HeroHanzoTargetPracticePlayerLosesRangeIncrease, false);
    TriggerAddEventUnitBehaviorChange(libHHAN_gt_HeroHanzoTargetPracticePlayerLosesRangeIncrease, null, "HanzoTargetPracticeRangeIncrease", c_unitBehaviorChangeDestroy);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Hanzo - Target Practice - Player Respecs
//--------------------------------------------------------------------------------------------------
bool libHHAN_gt_HeroHanzoTargetPracticePlayerRespecs_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_player;

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

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

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

    libHHAN_gf_HeroHanzoTargetPracticeResetQuestProgress(lv_player);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHHAN_gt_HeroHanzoTargetPracticePlayerRespecs_Init () {
    libHHAN_gt_HeroHanzoTargetPracticePlayerRespecs = TriggerCreate("libHHAN_gt_HeroHanzoTargetPracticePlayerRespecs_Func");
    TriggerEnable(libHHAN_gt_HeroHanzoTargetPracticePlayerRespecs, false);
    libGame_gf_HeroRespecsTalents(libHHAN_gt_HeroHanzoTargetPracticePlayerRespecs);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Hanzo - Target Practice - Hero Spawned
//--------------------------------------------------------------------------------------------------
bool libHHAN_gt_HeroHanzoTargetPracticeHeroSpawned_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    const int autoFA6CBC1D_ae = libCore_gv_bALMaxPlayers;
    int autoFA6CBC1D_var;

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

    autoFA6CBC1D_var = 1;
    for ( ; autoFA6CBC1D_var <= autoFA6CBC1D_ae; autoFA6CBC1D_var += 1 ) {
        if ((PlayerHasTalent(autoFA6CBC1D_var, "HanzoTargetPractice") == true)) {
            libHHAN_gf_HeroHanzoTargetPracticeResetQuestProgress(autoFA6CBC1D_var);
            libHHAN_gf_HeroHanzoTargetPracticeConfigureQuestForPlayer(autoFA6CBC1D_var);
        }

    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHHAN_gt_HeroHanzoTargetPracticeHeroSpawned_Init () {
    libHHAN_gt_HeroHanzoTargetPracticeHeroSpawned = TriggerCreate("libHHAN_gt_HeroHanzoTargetPracticeHeroSpawned_Func");
    TriggerEnable(libHHAN_gt_HeroHanzoTargetPracticeHeroSpawned, false);
    libGame_gf_HeroSpawn(libHHAN_gt_HeroHanzoTargetPracticeHeroSpawned);
    libGame_gf_DebugHeroSwapped(libHHAN_gt_HeroHanzoTargetPracticeHeroSpawned);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Hanzo - Target Practice - Clone or Mech Spawned
//--------------------------------------------------------------------------------------------------
bool libHHAN_gt_HeroHanzoTargetPracticeCloneorMechSpawned_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_createdUnit;
    int lv_player;
    unit lv_heroUnit;
    unit lv_originatingHanzo;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_createdUnit = EventUnitCreatedUnit();
    lv_player = UnitGetOwner(lv_createdUnit);

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

        if (!(((UnitGetType(lv_createdUnit) == "SamuroMirrorImage") || (UnitGetType(lv_createdUnit) == "HeroDVaMech") || (UnitGetType(lv_createdUnit) == "NovaHoloClone")))) {
            return false;
        }
    }

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

    lv_heroUnit = libGame_gv_players[lv_player].lv_heroUnit;
    if ((UnitHasBehavior2(lv_heroUnit, "HanzoTargetPracticeOwnershipDummy") == true)) {
    }
    else {
        return true;
    }
    lv_originatingHanzo = UnitBehaviorEffectUnit(lv_heroUnit, "HanzoTargetPracticeOwnershipDummy", c_effectUnitCaster, 0);
    UnitBehaviorAdd(lv_createdUnit, "HanzoTargetPracticeOwnershipDummy", lv_originatingHanzo, 1);
    UnitBehaviorAdd(lv_createdUnit, "HanzoTargetPracticeTargetTokenCounter", lv_originatingHanzo, 1);
    UnitSetTokenCount(lv_createdUnit, "HanzoTargetPracticeTargetTokenCounter", UnitGetTokenCount(lv_heroUnit, "HanzoTargetPracticeTargetTokenCounter"), lv_originatingHanzo);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHHAN_gt_HeroHanzoTargetPracticeCloneorMechSpawned_Init () {
    libHHAN_gt_HeroHanzoTargetPracticeCloneorMechSpawned = TriggerCreate("libHHAN_gt_HeroHanzoTargetPracticeCloneorMechSpawned_Func");
    TriggerEnable(libHHAN_gt_HeroHanzoTargetPracticeCloneorMechSpawned, false);
    TriggerAddEventUnitCreated(libHHAN_gt_HeroHanzoTargetPracticeCloneorMechSpawned, null, null, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Hanzo - Ninja Assassin - Refresh Natural Agility on Takedown
//--------------------------------------------------------------------------------------------------
bool libHHAN_gt_HeroHanzoNinjaAssassinRefreshNaturalAgilityonTakedown_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_hanzoPlayer;
    unit lv_hanzoUnit;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_hanzoPlayer = libGame_gf_HeroParticipatedInTakedownKillingPlayer();
    lv_hanzoUnit = libGame_gv_players[lv_hanzoPlayer].lv_heroUnit;

    // Conditions
    if (testConds) {
        if (!((UnitGetType(lv_hanzoUnit) == "HeroHanzo"))) {
            return false;
        }

        if (!((PlayerHasTalent(lv_hanzoPlayer, "HanzoNinjaAssassin") == true))) {
            return false;
        }
    }

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

    UnitAddChargeUsed(lv_hanzoUnit, "Abil/HanzoNaturalAgilityButton", -1.0);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHHAN_gt_HeroHanzoNinjaAssassinRefreshNaturalAgilityonTakedown_Init () {
    libHHAN_gt_HeroHanzoNinjaAssassinRefreshNaturalAgilityonTakedown = TriggerCreate("libHHAN_gt_HeroHanzoNinjaAssassinRefreshNaturalAgilityonTakedown_Func");
    TriggerEnable(libHHAN_gt_HeroHanzoNinjaAssassinRefreshNaturalAgilityonTakedown, false);
    libGame_gf_HeroParticipatedInTakedown(libHHAN_gt_HeroHanzoNinjaAssassinRefreshNaturalAgilityonTakedown);
}

void libHHAN_InitTriggers () {
    libHHAN_gt_HeroHanzoDragonstrikeSearch_Init();
    libHHAN_gt_HeroHanzoScatterArrowPlayImpactFX_Init();
    libHHAN_gt_HeroHanzoSonicArrowUnitGainsTrackingBehavior_Init();
    libHHAN_gt_HeroHanzoStormBowCharging_Init();
    libHHAN_gt_HeroHanzoTargetPracticeTalentSelected_Init();
    libHHAN_gt_HeroHanzoTargetPracticeHeroHitByStormBow_Init();
    libHHAN_gt_HeroHanzoTargetPracticePlayerGetsRangeIncrease_Init();
    libHHAN_gt_HeroHanzoTargetPracticePlayerLosesRangeIncrease_Init();
    libHHAN_gt_HeroHanzoTargetPracticePlayerRespecs_Init();
    libHHAN_gt_HeroHanzoTargetPracticeHeroSpawned_Init();
    libHHAN_gt_HeroHanzoTargetPracticeCloneorMechSpawned_Init();
    libHHAN_gt_HeroHanzoNinjaAssassinRefreshNaturalAgilityonTakedown_Init();
}

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

void libHHAN_InitLib () {
    if (libHHAN_InitLib_completed) {
        return;
    }

    libHHAN_InitLib_completed = true;

    libHHAN_InitLibraries();
    libHHAN_InitVariables();
    libHHAN_InitTriggers();
}