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