include "TriggerLibs/NativeLib"
include "TriggerLibs/HeroesLib"
include "TriggerLibs/GameLib"
include "TriggerLibs/MapMechanicsLib"
include "TriggerLibs/AILib"
include "TriggerLibs/UILib"
include "TriggerLibs/SoundLib"
include "TriggerLibs/GameDataHelperLib"
include "TriggerLibs/SupportLib"
include "LibHSAM_h"
//--------------------------------------------------------------------------------------------------
// Library: Samuro
//--------------------------------------------------------------------------------------------------
// External Library Initialization
void libHSAM_InitLibraries () {
libNtve_InitVariables();
libCore_InitVariables();
libGame_InitVariables();
libMapM_InitVariables();
libAIAI_InitVariables();
libUIUI_InitVariables();
libSond_InitVariables();
libGDHL_InitVariables();
libSprt_InitVariables();
}
// Variable Initialization
bool libHSAM_InitVariables_completed = false;
void libHSAM_InitVariables () {
int init_i;
if (libHSAM_InitVariables_completed) {
return;
}
libHSAM_InitVariables_completed = true;
for (init_i = 0; init_i <= libCore_gv_bALMaxPlayers; init_i += 1) {
libHSAM_gv_mirrorImageUnitGroup[init_i] = UnitGroupEmpty();
}
for (init_i = 0; init_i <= libCore_gv_bALMaxPlayers; init_i += 1) {
libHSAM_gv_mirrorImageUnitGroup2[init_i] = UnitGroupEmpty();
}
for (init_i = 0; init_i <= libCore_gv_bALMaxPlayers; init_i += 1) {
libHSAM_gv_mirrorImageUnitGroup3[init_i] = UnitGroupEmpty();
}
libHSAM_gv_samuro_ControlGroupPanel = c_invalidDialogControlId;
libHSAM_gv_samuroUI.lv_samuroControlGroupIcon0 = c_invalidDialogControlId;
libHSAM_gv_samuroUI.lv_samuroControlGroupIcon1 = c_invalidDialogControlId;
libHSAM_gv_samuroUI.lv_samuroControlGroupIcon2 = c_invalidDialogControlId;
libHSAM_gv_samuroUI.lv_samuroControlGroupIcon3 = c_invalidDialogControlId;
libHSAM_gv_samuroUI.lv_samuroControlGroupIconHealth1 = c_invalidDialogControlId;
libHSAM_gv_samuroUI.lv_samuroControlGroupIconHealth2 = c_invalidDialogControlId;
}
// Presets
// Functions
void libHSAM_gf_HeroSamuroIncrementHeroCountFunction () {
// Automatic Variable Declarations
// Implementation
libHSAM_gv_heroSamuroTriggerRegistrationVariable += 1;
if ((libHSAM_gv_heroSamuroTriggerRegistrationVariable == 1)) {
TriggerEnable(libHSAM_gt_SamuroSelectionChange, true);
TriggerEnable(libHSAM_gt_SamuroRespawn, true);
TriggerEnable(libHSAM_gt_SamuroMirrorImageMountDismountPort, true);
TriggerEnable(libHSAM_gt_SamuroDebugSwap, true);
TriggerEnable(libHSAM_gt_SamuroSamuroDies, true);
TriggerEnable(libHSAM_gt_SamuroMirrorImageSwap, true);
TriggerEnable(libHSAM_gt_SamuroMirrorImageCreated, true);
TriggerEnable(libHSAM_gt_SamuroMirrorImageDies, true);
TriggerEnable(libHSAM_gt_SamuroMirrorImageController, true);
TriggerEnable(libHSAM_gt_SamuroBladestorm, true);
TriggerEnable(libHSAM_gt_SamuroGainsR2Talent, true);
TriggerEnable(libHSAM_gt_SamuroMirage, true);
TriggerEnable(libHSAM_gt_SamuroMirrorImageSelectedOn, true);
TriggerEnable(libHSAM_gt_SamuroMirrorImageSelectedOff, true);
TriggerEnable(libHSAM_gt_SamuroMirrorImageIllusionMasterAIToggleOn, true);
TriggerEnable(libHSAM_gt_SamuroMirrorImageIllusionMasterAIToggleOff, true);
TriggerEnable(libHSAM_gt_SamuroMirrorImageAttackOrderRedirectAI, true);
TriggerEnable(libHSAM_gt_SamuroRespecsTalents, true);
TriggerEnable(libHSAM_gt_SamuroUsesTransport, true);
TriggerEnable(libHSAM_gt_SamuroControlGroupHighlightSelectionController, true);
TriggerEnable(libHSAM_gt_SamuroMirrorImageHealthTrackerCreate, true);
TriggerEnable(libHSAM_gt_SamuroMirrorImageHealthTrackerCreateTalentTaken, true);
TriggerEnable(libHSAM_gt_SamuroMirrorImageHealthTrackerUpdate, true);
TriggerEnable(libHSAM_gt_SamuroGainsMapMechanicStack, true);
TriggerEnable(libHSAM_gt_SamuroLosesWayofIllusion, true);
TriggerEnable(libHSAM_gt_SamuroMirrorImageDamageTakenDuplication, true);
}
}
void libHSAM_gf_HeroSamuroDecrementHeroCountFunction () {
// Automatic Variable Declarations
// Implementation
libHSAM_gv_heroSamuroTriggerRegistrationVariable -= 1;
if ((libHSAM_gv_heroSamuroTriggerRegistrationVariable < 0)) {
libHSAM_gv_heroSamuroTriggerRegistrationVariable = 0;
}
if ((libHSAM_gv_heroSamuroTriggerRegistrationVariable == 0)) {
TriggerEnable(libHSAM_gt_SamuroSelectionChange, false);
TriggerEnable(libHSAM_gt_SamuroRespawn, false);
TriggerEnable(libHSAM_gt_SamuroMirrorImageMountDismountPort, false);
TriggerEnable(libHSAM_gt_SamuroDebugSwap, false);
TriggerEnable(libHSAM_gt_SamuroSamuroDies, false);
TriggerEnable(libHSAM_gt_SamuroMirrorImageSwap, false);
TriggerEnable(libHSAM_gt_SamuroMirrorImageCreated, false);
TriggerEnable(libHSAM_gt_SamuroMirrorImageDies, false);
TriggerEnable(libHSAM_gt_SamuroMirrorImageController, false);
TriggerEnable(libHSAM_gt_SamuroBladestorm, false);
TriggerEnable(libHSAM_gt_SamuroGainsR2Talent, false);
TriggerEnable(libHSAM_gt_SamuroMirage, false);
TriggerEnable(libHSAM_gt_SamuroMirrorImageSelectedOn, false);
TriggerEnable(libHSAM_gt_SamuroMirrorImageSelectedOff, false);
TriggerEnable(libHSAM_gt_SamuroMirrorImageIllusionMasterAIToggleOn, false);
TriggerEnable(libHSAM_gt_SamuroMirrorImageIllusionMasterAIToggleOff, false);
TriggerEnable(libHSAM_gt_SamuroMirrorImageAttackOrderRedirectAI, false);
TriggerEnable(libHSAM_gt_SamuroRespecsTalents, false);
TriggerEnable(libHSAM_gt_SamuroUsesTransport, false);
TriggerEnable(libHSAM_gt_SamuroControlGroupHighlightSelectionController, false);
TriggerEnable(libHSAM_gt_SamuroMirrorImageHealthTrackerCreate, false);
TriggerEnable(libHSAM_gt_SamuroMirrorImageHealthTrackerCreateTalentTaken, false);
TriggerEnable(libHSAM_gt_SamuroMirrorImageHealthTrackerUpdate, false);
TriggerEnable(libHSAM_gt_SamuroGainsMapMechanicStack, false);
TriggerEnable(libHSAM_gt_SamuroLosesWayofIllusion, false);
TriggerEnable(libHSAM_gt_SamuroMirrorImageDamageTakenDuplication, false);
}
}
trigger auto_libHSAM_gf_HeroSamuroMirrorImageAI_Trigger = null;
unit auto_libHSAM_gf_HeroSamuroMirrorImageAI_lp_samuro;
unit auto_libHSAM_gf_HeroSamuroMirrorImageAI_lp_mirrorImage;
int auto_libHSAM_gf_HeroSamuroMirrorImageAI_lp_samuroPlayer;
void libHSAM_gf_HeroSamuroMirrorImageAI (unit lp_samuro, unit lp_mirrorImage, int lp_samuroPlayer) {
auto_libHSAM_gf_HeroSamuroMirrorImageAI_lp_samuro = lp_samuro;
auto_libHSAM_gf_HeroSamuroMirrorImageAI_lp_mirrorImage = lp_mirrorImage;
auto_libHSAM_gf_HeroSamuroMirrorImageAI_lp_samuroPlayer = lp_samuroPlayer;
if (auto_libHSAM_gf_HeroSamuroMirrorImageAI_Trigger == null) {
auto_libHSAM_gf_HeroSamuroMirrorImageAI_Trigger = TriggerCreate("auto_libHSAM_gf_HeroSamuroMirrorImageAI_TriggerFunc");
}
TriggerExecute(auto_libHSAM_gf_HeroSamuroMirrorImageAI_Trigger, false, false);
}
bool auto_libHSAM_gf_HeroSamuroMirrorImageAI_TriggerFunc (bool testConds, bool runActions) {
unit lp_samuro = auto_libHSAM_gf_HeroSamuroMirrorImageAI_lp_samuro;
unit lp_mirrorImage = auto_libHSAM_gf_HeroSamuroMirrorImageAI_lp_mirrorImage;
int lp_samuroPlayer = auto_libHSAM_gf_HeroSamuroMirrorImageAI_lp_samuroPlayer;
// Variable Declarations
unit lv_unitToFollow;
int lv_mirrorImageState;
unit lv_mirrorImageAggroTarget;
// Automatic Variable Declarations
// Variable Initialization
lv_unitToFollow = lp_samuro;
// Implementation
while ((UnitHasBehavior2(lp_mirrorImage, "SamuroMirrorImageSelectedBehavior") == false) && (UnitIsAlive(lp_mirrorImage) == true) && (UnitHasAnyOrderWithFlag(lp_mirrorImage, c_cmdUser) == false)) {
if ((libGame_gv_players[lp_samuroPlayer].lv_activeVehicle != null) && (lv_unitToFollow != libGame_gv_players[lp_samuroPlayer].lv_activeVehicle)) {
lv_unitToFollow = libGame_gv_players[lp_samuroPlayer].lv_activeVehicle;
}
else if ((libGame_gv_players[lp_samuroPlayer].lv_activeVehicle == null) && (lv_unitToFollow != lp_samuro)) {
lv_unitToFollow = lp_samuro;
}
if ((UnitOrder(lp_mirrorImage, 0) == null) && (lv_mirrorImageState != libHSAM_ge_MirrorImageState_Idle)) {
lv_mirrorImageState = libHSAM_ge_MirrorImageState_Idle;
}
else {
if ((lv_mirrorImageState != libHSAM_ge_MirrorImageState_Aggro) && (OrderGetAbilityCommand(UnitOrder(lp_mirrorImage, 0)) == AbilityCommand("attack", 0))) {
lv_mirrorImageState = libHSAM_ge_MirrorImageState_Aggro;
}
}
if ((PlayerHasTalent(lp_samuroPlayer, "SamuroHeroicAbilityIllusionMaster") == false) && (lv_mirrorImageState != libHSAM_ge_MirrorImageState_Aggro) && (DistanceBetweenPoints(UnitGetPosition(lp_mirrorImage), UnitGetPosition(lp_samuro)) > 8.0)) {
Wait(1.0, c_timeGame);
lv_mirrorImageState = libHSAM_ge_MirrorImageState_Leashing;
UnitIssueOrder(lp_mirrorImage, OrderTargetingPoint(AbilityCommand("move", 0), PointWithOffsetPolar(UnitGetPosition(lp_samuro), 0.5, libNtve_gf_RandomAngle())), c_orderQueueReplace);
}
else {
if ((PlayerHasTalent(lp_samuroPlayer, "SamuroHeroicAbilityIllusionMaster") == false) && (lv_mirrorImageState == libHSAM_ge_MirrorImageState_Aggro) && (DistanceBetweenPoints(UnitGetPosition(lp_mirrorImage), UnitGetPosition(lp_samuro)) > 17.0)) {
UnitIssueOrder(lp_mirrorImage, OrderTargetingPoint(AbilityCommand("move", 0), PointWithOffsetPolar(UnitGetPosition(lp_samuro), 0.5, libNtve_gf_RandomAngle())), c_orderQueueReplace);
lv_mirrorImageState = libHSAM_ge_MirrorImageState_Leashing;
}
}
Wait(0.125, c_timeGame);
}
return true;
}
void libHSAM_gf_SamuroUISetup (unit lp_CreatedUnit) {
// Variable Declarations
int lv_samuroPlayer;
unit lv_samuro;
// Automatic Variable Declarations
// Variable Initialization
// Implementation
lv_samuroPlayer = UnitGetOwner(lp_CreatedUnit);
lv_samuro = lp_CreatedUnit;
UnitControlGroupAddUnit(lv_samuroPlayer, 1, lv_samuro);
UnitControlGroupAddUnit(lv_samuroPlayer, 4, lv_samuro);
UISetSelectionTypeEnabled(PlayerGroupSingle(lv_samuroPlayer), c_localSelectionTypeUnknown, true);
UISetDragSelectEnabled(PlayerGroupSingle(lv_samuroPlayer), true);
UISetFrameVisible(PlayerGroupSingle(lv_samuroPlayer), c_syncFrameTypeControlGroupPanel, true);
}
void libHSAM_gf_SamuroMirrorImagesTransferDurations (unit lp_samuro, unit lp_mirrorImage) {
// Variable Declarations
fixed lv_advancingStrikeRemainingDuration;
fixed lv_criticalStrikeActivatedRemainingDuration;
string lv_behavior;
// Automatic Variable Declarations
// Variable Initialization
lv_advancingStrikeRemainingDuration = UnitBehaviorDuration(lp_samuro, "SamuroAdvancingStrikesMoveSpeedBuff");
lv_criticalStrikeActivatedRemainingDuration = UnitBehaviorDuration(lp_samuro, "SamuroCriticalStrikeTimed");
// Implementation
lv_behavior = "SamuroAdvancingStrikesMoveSpeedBuff";
if ((UnitHasBehavior2(lp_samuro, lv_behavior) == true) && (UnitHasBehavior2(lp_mirrorImage, lv_behavior) == true)) {
UnitBehaviorSetDurationRemaining(lp_mirrorImage, lv_behavior, lv_advancingStrikeRemainingDuration);
}
else {
UnitBehaviorRemove(lp_mirrorImage, lv_behavior, 1);
}
lv_behavior = "SamuroAdvancingStrikesDeflectionBlock";
if ((UnitHasBehavior2(lp_samuro, lv_behavior) == true) && (UnitHasBehavior2(lp_mirrorImage, lv_behavior) == true)) {
UnitBehaviorSetDurationRemaining(lp_mirrorImage, lv_behavior, lv_advancingStrikeRemainingDuration);
}
else {
UnitBehaviorRemove(lp_mirrorImage, lv_behavior, 1);
}
lv_behavior = "SamuroCriticalStrikeTimed";
if ((UnitHasBehavior2(lp_samuro, lv_behavior) == true) && (UnitHasBehavior2(lp_mirrorImage, lv_behavior) == true)) {
UnitBehaviorSetDurationRemaining(lp_mirrorImage, lv_behavior, lv_criticalStrikeActivatedRemainingDuration);
}
else {
UnitBehaviorRemove(lp_mirrorImage, lv_behavior, 1);
}
}
trigger auto_libHSAM_gf_SamuroMirrorImageAIActivationRetainOrderDelay_Trigger = null;
unit auto_libHSAM_gf_SamuroMirrorImageAIActivationRetainOrderDelay_lp_mirrorImageUnit;
void libHSAM_gf_SamuroMirrorImageAIActivationRetainOrderDelay (unit lp_mirrorImageUnit) {
auto_libHSAM_gf_SamuroMirrorImageAIActivationRetainOrderDelay_lp_mirrorImageUnit = lp_mirrorImageUnit;
if (auto_libHSAM_gf_SamuroMirrorImageAIActivationRetainOrderDelay_Trigger == null) {
auto_libHSAM_gf_SamuroMirrorImageAIActivationRetainOrderDelay_Trigger = TriggerCreate("auto_libHSAM_gf_SamuroMirrorImageAIActivationRetainOrderDelay_TriggerFunc");
}
TriggerExecute(auto_libHSAM_gf_SamuroMirrorImageAIActivationRetainOrderDelay_Trigger, false, false);
}
bool auto_libHSAM_gf_SamuroMirrorImageAIActivationRetainOrderDelay_TriggerFunc (bool testConds, bool runActions) {
unit lp_mirrorImageUnit = auto_libHSAM_gf_SamuroMirrorImageAIActivationRetainOrderDelay_lp_mirrorImageUnit;
// Automatic Variable Declarations
// Implementation
if ((UnitIsValid(lp_mirrorImageUnit) == true) && (UnitHasBehavior2(lp_mirrorImageUnit, "SamuroMirrorImageSelectedBehavior") == false) && (UnitHasBehavior2(lp_mirrorImageUnit, "MirrorImageAIToggledOff") == false)) {
Wait(0.125, c_timeGame);
while ((UnitIsValid(lp_mirrorImageUnit) == true) && (UnitOrderCount(lp_mirrorImageUnit) >= 1) && (UnitHasBehavior2(lp_mirrorImageUnit, "SamuroMirrorImageSelectedBehavior") == false) && (UnitHasBehavior2(lp_mirrorImageUnit, "MirrorImageAIToggledOff") == false)) {
Wait(0.25, c_timeGame);
}
if ((UnitIsValid(lp_mirrorImageUnit) == true) && (UnitHasBehavior2(lp_mirrorImageUnit, "SamuroMirrorImageSelectedBehavior") == false) && (UnitHasBehavior2(lp_mirrorImageUnit, "MirrorImageAIToggledOff") == false)) {
if (((PlayerHasTalent(UnitGetOwner(lp_mirrorImageUnit), "SamuroHeroicAbilityIllusionMaster") == false) || (UnitHasBehavior2(libGame_gv_players[UnitGetOwner(lp_mirrorImageUnit)].lv_heroUnit, "SamuroIllusionMasterToggleAI") == false))) {
UnitCreateAIThinkTree(lp_mirrorImageUnit);
}
else {
UnitBehaviorRemove(lp_mirrorImageUnit, "MirrorImageAIToggledOff", 1);
UnitBehaviorAdd(lp_mirrorImageUnit, "SamuroMirrorImageAggroBehavior", lp_mirrorImageUnit, 1);
if ((libAIAI_gf_HeroAIIsAIEnabledForPlayer(UnitGetOwner(EventUnit())) == true)) {
UnitCreateAIThinkTree(lp_mirrorImageUnit);
}
}
}
}
return true;
}
void libHSAM_gf_SamuroKawarimi (unit lp_imageUnit) {
// Variable Declarations
unit lv_samuro;
int lv_orderCount;
// Automatic Variable Declarations
// Variable Initialization
// Implementation
lv_samuro = libGame_gv_players[UnitGetOwner(lp_imageUnit)].lv_heroUnit;
lv_orderCount = UnitOrderCount(lv_samuro);
UnitOrderCopy(lv_samuro, lp_imageUnit, lv_orderCount);
UnitCreateEffectUnit(lp_imageUnit, "SamuroKawarimiCancelHearthstoneOrder", lp_imageUnit);
}
void libHSAM_gf_SamuroUIUnSetupUIForPlayer (int lp_player) {
// Automatic Variable Declarations
// Implementation
DialogControlSetVisible(libHSAM_gv_samuroUI.lv_samuroControlGroupIcon0, libCore_gv_playerGroupFromPlayer[lp_player], false);
DialogControlSetVisible(libHSAM_gv_samuroUI.lv_samuroControlGroupIcon1, libCore_gv_playerGroupFromPlayer[lp_player], false);
DialogControlSetVisible(libHSAM_gv_samuroUI.lv_samuroControlGroupIcon2, libCore_gv_playerGroupFromPlayer[lp_player], false);
DialogControlSetVisible(libHSAM_gv_samuroUI.lv_samuroControlGroupIcon3, libCore_gv_playerGroupFromPlayer[lp_player], false);
DialogControlSetVisible(libHSAM_gv_samuroUI.lv_samuroControlGroupIconHealth1, libCore_gv_playerGroupFromPlayer[lp_player], false);
DialogControlSetVisible(libHSAM_gv_samuroUI.lv_samuroControlGroupIconHealth2, libCore_gv_playerGroupFromPlayer[lp_player], false);
}
// Triggers
//--------------------------------------------------------------------------------------------------
// Trigger: Force Include Data Mods
//--------------------------------------------------------------------------------------------------
bool libHSAM_gt_ForceIncludeDataMods_Func (bool testConds, bool runActions) {
// Automatic Variable Declarations
// Actions
if (!runActions) {
return true;
}
TriggerExecute(libAIAI_gt_IncludeAI, true, false);
TriggerExecute(libGame_gt_IncludeGame, true, false);
TriggerExecute(libGDHL_gt_IncludeGameDataHelper, true, false);
TriggerExecute(libMapM_gt_IncludeMapMechanics, true, false);
TriggerExecute(libSond_gt_IncludeSound, true, false);
TriggerExecute(libSprt_gt_IncludeSupport, true, false);
TriggerExecute(libUIUI_gt_IncludeUI, true, false);
return true;
}
//--------------------------------------------------------------------------------------------------
void libHSAM_gt_ForceIncludeDataMods_Init () {
libHSAM_gt_ForceIncludeDataMods = TriggerCreate("libHSAM_gt_ForceIncludeDataMods_Func");
TriggerAddEventMapInit(libHSAM_gt_ForceIncludeDataMods);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Samuro - Selection Change
//--------------------------------------------------------------------------------------------------
bool libHSAM_gt_SamuroSelectionChange_Func (bool testConds, bool runActions) {
// Variable Declarations
int lv_eventPlayer;
unit lv_ClosestUnit;
unit lv_itUnit;
// Automatic Variable Declarations
unitgroup auto078DF349_g;
int auto078DF349_u;
// Variable Initialization
lv_eventPlayer = EventPlayer();
// Conditions
if (testConds) {
if (!(((UnitGetType(libGame_gv_players[lv_eventPlayer].lv_heroUnit) == "HeroSamuro") || (UnitGetType(libGame_gv_players[lv_eventPlayer].lv_activeVehicle) == "HeroSamuro")))) {
return false;
}
if (!((UnitHasBehavior2(libGame_gv_players[lv_eventPlayer].lv_heroUnit, "FirebatBunkerDropPassengerUnitInsideBunker") == false))) {
return false;
}
if (!((UnitHasBehavior2(libGame_gv_players[lv_eventPlayer].lv_activeVehicle, "FirebatBunkerDropPassengerUnitInsideBunker") == false))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
auto078DF349_g = UnitGroupSelected(lv_eventPlayer);
auto078DF349_u = UnitGroupCount(auto078DF349_g, c_unitCountAll);
for (;; auto078DF349_u -= 1) {
lv_itUnit = UnitGroupUnitFromEnd(auto078DF349_g, auto078DF349_u);
if (lv_itUnit == null) { break; }
if (((UnitGetType(lv_itUnit) == "HeroSamuro") || (lv_itUnit == libGame_gv_players[lv_eventPlayer].lv_activeVehicle))) {
libGame_gv_players[lv_eventPlayer].lv_cameraPlayerUnitGroupToFocusOn = libNtve_gf_ConvertUnitToUnitGroup(lv_itUnit);
libGame_gf_CameraUpdateCameraForPlayer(lv_eventPlayer);
return true;
}
}
lv_ClosestUnit = UnitGroupClosestToPoint(UnitGroupSelected(lv_eventPlayer), CameraGetTarget(lv_eventPlayer));
if (((UnitGetType(lv_ClosestUnit) == "SamuroMirrorImage") && (UnitTestState(lv_ClosestUnit, c_unitStateIsDead) == false))) {
libGame_gv_players[lv_eventPlayer].lv_cameraPlayerUnitGroupToFocusOn = libNtve_gf_ConvertUnitToUnitGroup(lv_ClosestUnit);
libGame_gf_CameraUpdateCameraForPlayer(lv_eventPlayer);
}
else {
UnitGroupSelect(UnitGroupSelected(lv_eventPlayer), lv_eventPlayer, false);
if ((UnitGetType(libGame_gv_players[lv_eventPlayer].lv_activeVehicle) == "")) {
UnitSelect(libGame_gv_players[lv_eventPlayer].lv_heroUnit, lv_eventPlayer, true);
}
else {
UnitSelect(libGame_gv_players[lv_eventPlayer].lv_activeVehicle, lv_eventPlayer, true);
}
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHSAM_gt_SamuroSelectionChange_Init () {
libHSAM_gt_SamuroSelectionChange = TriggerCreate("libHSAM_gt_SamuroSelectionChange_Func");
TriggerEnable(libHSAM_gt_SamuroSelectionChange, false);
TriggerAddEventUnitSelected(libHSAM_gt_SamuroSelectionChange, null, c_playerAny, true);
TriggerAddEventUnitSelected(libHSAM_gt_SamuroSelectionChange, null, c_playerAny, false);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Samuro - Respawn
//--------------------------------------------------------------------------------------------------
bool libHSAM_gt_SamuroRespawn_Func (bool testConds, bool runActions) {
// Variable Declarations
int lv_Samuro;
// Automatic Variable Declarations
// Variable Initialization
lv_Samuro = libGame_gf_HeroRespawnPlayer();
// Conditions
if (testConds) {
if (!((UnitGetType(libGame_gv_players[lv_Samuro].lv_heroUnit) == "HeroSamuro"))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
UnitSelect(libGame_gv_players[lv_Samuro].lv_heroUnit, lv_Samuro, true);
return true;
}
//--------------------------------------------------------------------------------------------------
void libHSAM_gt_SamuroRespawn_Init () {
libHSAM_gt_SamuroRespawn = TriggerCreate("libHSAM_gt_SamuroRespawn_Func");
TriggerEnable(libHSAM_gt_SamuroRespawn, false);
libGame_gf_HeroRespawn(libHSAM_gt_SamuroRespawn);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Samuro - Port
//--------------------------------------------------------------------------------------------------
bool libHSAM_gt_SamuroPort_Func (bool testConds, bool runActions) {
// Variable Declarations
int lv_samuroPlayer;
// Automatic Variable Declarations
unitgroup auto4020C64D_g;
int auto4020C64D_u;
unit auto4020C64D_var;
// Variable Initialization
lv_samuroPlayer = EventPlayer();
// Conditions
if (testConds) {
if (!(((UnitGetType(libGame_gv_players[lv_samuroPlayer].lv_activeVehicle) == "HeroSamuro") || (UnitGetType(libGame_gv_players[lv_samuroPlayer].lv_heroUnit) == "HeroSamuro")))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
if ((UnitGetType(EventPlayerEffectUsedUnit(c_effectUnitCaster)) == "HeroSamuro")) {
auto4020C64D_g = UnitGroup("SamuroMirrorImage", lv_samuroPlayer, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32))), 0);
auto4020C64D_u = UnitGroupCount(auto4020C64D_g, c_unitCountAll);
for (;; auto4020C64D_u -= 1) {
auto4020C64D_var = UnitGroupUnitFromEnd(auto4020C64D_g, auto4020C64D_u);
if (auto4020C64D_var == null) { break; }
UnitKill(auto4020C64D_var);
}
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHSAM_gt_SamuroPort_Init () {
libHSAM_gt_SamuroPort = TriggerCreate("libHSAM_gt_SamuroPort_Func");
TriggerEnable(libHSAM_gt_SamuroPort, false);
TriggerAddEventPlayerEffectUsed(libHSAM_gt_SamuroPort, c_playerAny, "HearthstoneTeleport");
}
//--------------------------------------------------------------------------------------------------
// Trigger: Samuro Debug Swap
//--------------------------------------------------------------------------------------------------
bool libHSAM_gt_SamuroDebugSwap_Func (bool testConds, bool runActions) {
// Automatic Variable Declarations
// Conditions
if (testConds) {
if (!((PlayerHasTalent(libGame_gf_DebugHeroSwappedPlayer(), "SamuroHeroicAbilityIllusionMaster") == true))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
UnitControlGroupClear(libGame_gf_DebugHeroSwappedPlayer(), 1);
UISetFrameVisible(PlayerGroupSingle(libGame_gf_DebugHeroSwappedPlayer()), c_syncFrameTypeControlGroupPanel, false);
DialogControlSetVisible(libUIUI_gv_uIHeroConsole.lv_heroStatsFrame, libCore_gv_playerGroupFromPlayer[libGame_gf_DebugHeroSwappedPlayer()], true);
if ((UnitGetType(libGame_gv_players[libGame_gf_DebugHeroSwappedPlayer()].lv_heroUnit) == "HeroSamuro")) {
Wait(0.0625, c_timeGame);
libHSAM_gf_SamuroUISetup(libGame_gv_players[libGame_gf_DebugHeroSwappedPlayer()].lv_heroUnit);
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHSAM_gt_SamuroDebugSwap_Init () {
libHSAM_gt_SamuroDebugSwap = TriggerCreate("libHSAM_gt_SamuroDebugSwap_Func");
TriggerEnable(libHSAM_gt_SamuroDebugSwap, false);
libGame_gf_DebugHeroSwapped(libHSAM_gt_SamuroDebugSwap);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Samuro - Respecs Talents
//--------------------------------------------------------------------------------------------------
bool libHSAM_gt_SamuroRespecsTalents_Func (bool testConds, bool runActions) {
// Variable Declarations
unit lv_samuro2;
int lv_Samuro;
// Automatic Variable Declarations
// Variable Initialization
lv_Samuro = libGame_gf_HeroRespecsTalentsPlayer();
// Conditions
if (testConds) {
if (!((UnitGetType(libGame_gv_players[lv_Samuro].lv_heroUnit) == "HeroSamuro"))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
UnitBehaviorRemove(libGame_gv_players[lv_Samuro].lv_heroUnit, "SamuroIllusionMasterToggleAIBehaviorAbil", 1);
UISetFrameVisible(PlayerGroupSingle(lv_Samuro), c_syncFrameTypeControlGroupPanel, false);
UnitControlGroupClear(lv_Samuro, 1);
UnitControlGroupClear(lv_Samuro, 2);
UnitControlGroupClear(lv_Samuro, 3);
UnitControlGroupClear(lv_Samuro, 4);
return true;
}
//--------------------------------------------------------------------------------------------------
void libHSAM_gt_SamuroRespecsTalents_Init () {
libHSAM_gt_SamuroRespecsTalents = TriggerCreate("libHSAM_gt_SamuroRespecsTalents_Func");
TriggerEnable(libHSAM_gt_SamuroRespecsTalents, false);
libGame_gf_HeroRespecsTalents(libHSAM_gt_SamuroRespecsTalents);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Samuro - Samuro Dies
//--------------------------------------------------------------------------------------------------
bool libHSAM_gt_SamuroSamuroDies_Func (bool testConds, bool runActions) {
// Automatic Variable Declarations
unitgroup auto12FB7577_g;
int auto12FB7577_u;
unit auto12FB7577_var;
// Conditions
if (testConds) {
if (!((UnitGetType(libGame_gf_HeroKilledUnit()) == "HeroSamuro"))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
auto12FB7577_g = libHSAM_gv_mirrorImageUnitGroup[UnitGetOwner(libGame_gf_HeroKilledUnit())];
auto12FB7577_u = UnitGroupCount(auto12FB7577_g, c_unitCountAll);
for (;; auto12FB7577_u -= 1) {
auto12FB7577_var = UnitGroupUnitFromEnd(auto12FB7577_g, auto12FB7577_u);
if (auto12FB7577_var == null) { break; }
UnitKill(auto12FB7577_var);
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHSAM_gt_SamuroSamuroDies_Init () {
libHSAM_gt_SamuroSamuroDies = TriggerCreate("libHSAM_gt_SamuroSamuroDies_Func");
TriggerEnable(libHSAM_gt_SamuroSamuroDies, false);
libGame_gf_HeroKilled(libHSAM_gt_SamuroSamuroDies);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Samuro - Uses Transport
//--------------------------------------------------------------------------------------------------
bool libHSAM_gt_SamuroUsesTransport_Func (bool testConds, bool runActions) {
// Variable Declarations
int lv_controlGroup;
int lv_samuroPlayer;
unit lv_fakeSelectionVehicle;
unit lv_samuroCargoUnit;
unit lv_transportUnit;
// Automatic Variable Declarations
string auto834489A3_val;
// Variable Initialization
lv_transportUnit = libGame_gf_HeroEnteredTransportTransport();
// Conditions
if (testConds) {
if (!((UnitGetType(libGame_gv_players[libGame_gf_HeroEnteredTransportPlayerEntering()].lv_heroUnit) == "HeroSamuro"))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
lv_samuroPlayer = libGame_gf_HeroEnteredTransportPlayerEntering();
lv_samuroCargoUnit = libGame_gf_HeroEnteredTransportCargoUnit();
libNtve_gf_CreateUnitsWithDefaultFacing(1, "SamuroMedivacDummyUnit", 0, lv_samuroPlayer, UnitGetPosition(lv_samuroCargoUnit), null);
lv_fakeSelectionVehicle = UnitLastCreated();
auto834489A3_val = UnitGetType(lv_samuroCargoUnit);
if (auto834489A3_val == "HeroSamuro") {
lv_controlGroup = 1;
}
else if (auto834489A3_val == "SamuroMirrorImage") {
if ((UnitGroupHasUnit(libHSAM_gv_mirrorImageUnitGroup2[lv_samuroPlayer], lv_samuroCargoUnit) == true)) {
lv_controlGroup = 2;
}
else {
lv_controlGroup = 3;
}
}
else {
}
UnitControlGroupAddUnit(lv_samuroPlayer, lv_controlGroup, lv_fakeSelectionVehicle);
UnitControlGroupRemoveUnit(lv_samuroPlayer, lv_controlGroup, lv_samuroCargoUnit);
UnitControlGroupRemoveUnit(lv_samuroPlayer, 4, lv_samuroCargoUnit);
UnitControlGroupAddUnit(lv_samuroPlayer, 4, lv_fakeSelectionVehicle);
while ((libNtve_gf_UnitIsInsideTransport(lv_samuroCargoUnit) == true)) {
UnitSetPosition(lv_fakeSelectionVehicle, UnitGetPosition(libGame_gf_HeroEnteredTransportTransport()), true);
Wait(0.0625, c_timeGame);
}
UnitSelect(lv_transportUnit, lv_samuroPlayer, false);
UnitSelect(lv_fakeSelectionVehicle, lv_samuroPlayer, false);
UnitControlGroupRemoveUnit(lv_samuroPlayer, lv_controlGroup, lv_fakeSelectionVehicle);
UnitControlGroupAddUnit(lv_samuroPlayer, lv_controlGroup, lv_samuroCargoUnit);
UnitControlGroupAddUnit(lv_samuroPlayer, 4, lv_samuroCargoUnit);
UnitControlGroupRemoveUnit(lv_samuroPlayer, 4, lv_fakeSelectionVehicle);
UnitRemove(lv_fakeSelectionVehicle);
UnitSelect(lv_samuroCargoUnit, lv_samuroPlayer, true);
if ((PlayerHasTalent(lv_samuroPlayer, "SamuroHeroicAbilityIllusionMaster") == false)) {
UnitControlGroupClear(lv_samuroPlayer, 1);
UnitControlGroupClear(lv_samuroPlayer, 2);
UnitControlGroupClear(lv_samuroPlayer, 3);
UnitControlGroupClear(lv_samuroPlayer, 4);
}
UIActivateDefaultSubgroup(lv_samuroPlayer);
libGame_gv_players[lv_samuroPlayer].lv_cameraCurrentTargetGroup = null;
libGame_gv_players[lv_samuroPlayer].lv_cameraPlayerUnitGroupToFocusOn = null;
libGame_gf_CameraUpdateCameraForPlayer(lv_samuroPlayer);
return true;
}
//--------------------------------------------------------------------------------------------------
void libHSAM_gt_SamuroUsesTransport_Init () {
libHSAM_gt_SamuroUsesTransport = TriggerCreate("libHSAM_gt_SamuroUsesTransport_Func");
TriggerEnable(libHSAM_gt_SamuroUsesTransport, false);
libGame_gf_HeroEnteredTransport(libHSAM_gt_SamuroUsesTransport);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Samuro - Gains Map Mechanic Stack
//--------------------------------------------------------------------------------------------------
bool libHSAM_gt_SamuroGainsMapMechanicStack_Func (bool testConds, bool runActions) {
// Variable Declarations
int lv_samuroPlayer;
// Automatic Variable Declarations
unitgroup autoAC2A871E_g;
int autoAC2A871E_u;
unit autoAC2A871E_var;
// Variable Initialization
// Conditions
if (testConds) {
if (!((UnitGetType(EventUnit()) == "HeroSamuro"))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
lv_samuroPlayer = UnitGetOwner(EventUnit());
if ((UnitGroupCount(libHSAM_gv_mirrorImageUnitGroup[lv_samuroPlayer], c_unitCountAlive) > 0)) {
autoAC2A871E_g = libHSAM_gv_mirrorImageUnitGroup[lv_samuroPlayer];
autoAC2A871E_u = UnitGroupCount(autoAC2A871E_g, c_unitCountAll);
for (;; autoAC2A871E_u -= 1) {
autoAC2A871E_var = UnitGroupUnitFromEnd(autoAC2A871E_g, autoAC2A871E_u);
if (autoAC2A871E_var == null) { break; }
UnitBehaviorRemove(autoAC2A871E_var, "MapMechanicStack", 0);
UnitBehaviorRemove(autoAC2A871E_var, "HasMapMechanicTargetAbility", 0);
UnitBehaviorRemove(autoAC2A871E_var, "HasMapMechanicTargetAbility2", 0);
UnitBehaviorRemove(autoAC2A871E_var, "HasMapMechanicInstantAbility", 0);
UnitBehaviorRemove(autoAC2A871E_var, "HasMapMechanicInstantAbility1", 0);
UnitBehaviorRemove(autoAC2A871E_var, "HasMapMechanicInstantAbility2", 0);
UnitBehaviorAdd(autoAC2A871E_var, "MapMechanicStack", libGame_gv_players[lv_samuroPlayer].lv_heroUnit, UnitBehaviorCount(libGame_gv_players[lv_samuroPlayer].lv_heroUnit, "MapMechanicStack"));
UnitBehaviorAdd(autoAC2A871E_var, "HasMapMechanicTargetAbility", libGame_gv_players[lv_samuroPlayer].lv_heroUnit, UnitBehaviorCount(libGame_gv_players[lv_samuroPlayer].lv_heroUnit, "HasMapMechanicTargetAbility"));
UnitBehaviorAdd(autoAC2A871E_var, "HasMapMechanicTargetAbility2", libGame_gv_players[lv_samuroPlayer].lv_heroUnit, UnitBehaviorCount(libGame_gv_players[lv_samuroPlayer].lv_heroUnit, "HasMapMechanicTargetAbility2"));
UnitBehaviorAdd(autoAC2A871E_var, "HasMapMechanicInstantAbility", libGame_gv_players[lv_samuroPlayer].lv_heroUnit, UnitBehaviorCount(libGame_gv_players[lv_samuroPlayer].lv_heroUnit, "HasMapMechanicInstantAbility"));
UnitBehaviorAdd(autoAC2A871E_var, "HasMapMechanicInstantAbility1", libGame_gv_players[lv_samuroPlayer].lv_heroUnit, UnitBehaviorCount(libGame_gv_players[lv_samuroPlayer].lv_heroUnit, "HasMapMechanicInstantAbility1"));
UnitBehaviorAdd(autoAC2A871E_var, "HasMapMechanicInstantAbility2", libGame_gv_players[lv_samuroPlayer].lv_heroUnit, UnitBehaviorCount(libGame_gv_players[lv_samuroPlayer].lv_heroUnit, "HasMapMechanicInstantAbility2"));
}
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHSAM_gt_SamuroGainsMapMechanicStack_Init () {
libHSAM_gt_SamuroGainsMapMechanicStack = TriggerCreate("libHSAM_gt_SamuroGainsMapMechanicStack_Func");
TriggerEnable(libHSAM_gt_SamuroGainsMapMechanicStack, false);
TriggerAddEventUnitBehaviorChange(libHSAM_gt_SamuroGainsMapMechanicStack, null, "MapMechanicStack", c_unitBehaviorChangeAny);
TriggerAddEventUnitBehaviorChange(libHSAM_gt_SamuroGainsMapMechanicStack, null, "HasMapMechanicTargetAbility", c_unitBehaviorChangeAny);
TriggerAddEventUnitBehaviorChange(libHSAM_gt_SamuroGainsMapMechanicStack, null, "HasMapMechanicTargetAbility2", c_unitBehaviorChangeAny);
TriggerAddEventUnitBehaviorChange(libHSAM_gt_SamuroGainsMapMechanicStack, null, "HasMapMechanicInstantAbility", c_unitBehaviorChangeAny);
TriggerAddEventUnitBehaviorChange(libHSAM_gt_SamuroGainsMapMechanicStack, null, "HasMapMechanicInstantAbility1", c_unitBehaviorChangeAny);
TriggerAddEventUnitBehaviorChange(libHSAM_gt_SamuroGainsMapMechanicStack, null, "HasMapMechanicInstantAbility2", c_unitBehaviorChangeAny);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Samuro - Mirror Image Selected On
//--------------------------------------------------------------------------------------------------
bool libHSAM_gt_SamuroMirrorImageSelectedOn_Func (bool testConds, bool runActions) {
// Variable Declarations
unit lv_mirrorImage;
// Automatic Variable Declarations
// Variable Initialization
lv_mirrorImage = EventUnit();
// Conditions
if (testConds) {
if (!((UnitGetType(lv_mirrorImage) == "SamuroMirrorImage"))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
if ((UnitHasBehavior2(lv_mirrorImage, "SamuroMirrorImageSelectedBehavior") == false)) {
UnitBehaviorAdd(lv_mirrorImage, "SamuroMirrorImageSelectedBehavior", lv_mirrorImage, 1);
UnitDestroyAIThinkTree(lv_mirrorImage);
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHSAM_gt_SamuroMirrorImageSelectedOn_Init () {
libHSAM_gt_SamuroMirrorImageSelectedOn = TriggerCreate("libHSAM_gt_SamuroMirrorImageSelectedOn_Func");
TriggerEnable(libHSAM_gt_SamuroMirrorImageSelectedOn, false);
TriggerAddEventUnitSelected(libHSAM_gt_SamuroMirrorImageSelectedOn, null, c_playerAny, true);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Samuro - Mirror Image Selected Off
//--------------------------------------------------------------------------------------------------
bool libHSAM_gt_SamuroMirrorImageSelectedOff_Func (bool testConds, bool runActions) {
// Variable Declarations
unit lv_mirrorImage;
// Automatic Variable Declarations
// Variable Initialization
lv_mirrorImage = EventUnit();
// Conditions
if (testConds) {
if (!((UnitGetType(lv_mirrorImage) == "SamuroMirrorImage"))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
if ((UnitHasBehavior2(lv_mirrorImage, "SamuroMirrorImageSelectedBehavior") == true)) {
UnitBehaviorRemove(lv_mirrorImage, "SamuroMirrorImageSelectedBehavior", 1);
libHSAM_gf_SamuroMirrorImageAIActivationRetainOrderDelay(lv_mirrorImage);
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHSAM_gt_SamuroMirrorImageSelectedOff_Init () {
libHSAM_gt_SamuroMirrorImageSelectedOff = TriggerCreate("libHSAM_gt_SamuroMirrorImageSelectedOff_Func");
TriggerEnable(libHSAM_gt_SamuroMirrorImageSelectedOff, false);
TriggerAddEventUnitSelected(libHSAM_gt_SamuroMirrorImageSelectedOff, null, c_playerAny, false);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Samuro - Mirror Image Swap
//--------------------------------------------------------------------------------------------------
bool libHSAM_gt_SamuroMirrorImageSwap_Func (bool testConds, bool runActions) {
// Variable Declarations
unit lv_samuro;
int lv_thisPlayer;
unit lv_image;
point lv_imageDestination;
fixed lv_samuroFacing;
fixed lv_imageFacing;
// Automatic Variable Declarations
unitgroup auto7073599F_g;
int auto7073599F_u;
unit auto7073599F_var;
// Variable Initialization
// Actions
if (!runActions) {
return true;
}
lv_thisPlayer = EventPlayer();
if ((UnitGetType(libGame_gv_players[lv_thisPlayer].lv_heroUnit) == "HeroAbathur")) {
lv_samuro = libGame_gv_players[lv_thisPlayer].lv_activeVehicle;
}
else {
lv_samuro = libGame_gv_players[lv_thisPlayer].lv_heroUnit;
}
lv_image = EventPlayerEffectUsedUnit(c_effectUnitTarget);
lv_imageDestination = UnitGetPosition(lv_samuro);
lv_samuroFacing = UnitGetFacing(lv_samuro);
lv_imageFacing = UnitGetFacing(lv_image);
UnitSetFacing(lv_samuro, lv_imageFacing, 0.0);
UnitSetFacing(lv_image, lv_samuroFacing, 0.0);
auto7073599F_g = libHSAM_gv_mirrorImageUnitGroup[lv_thisPlayer];
auto7073599F_u = UnitGroupCount(auto7073599F_g, c_unitCountAll);
for (;; auto7073599F_u -= 1) {
auto7073599F_var = UnitGroupUnitFromEnd(auto7073599F_g, auto7073599F_u);
if (auto7073599F_var == null) { break; }
UnitGroupSelect(libGame_gv_players[lv_thisPlayer].lv_heroUnitGroup, lv_thisPlayer, false);
libHSAM_gf_SamuroMirrorImagesTransferDurations(lv_samuro, auto7073599F_var);
}
UnitOrderSwap(lv_image, lv_samuro, 32);
UnitIssueOrder(lv_samuro, Order(AbilityCommand("SamuroIllusionMasterDummy", 0)), c_orderQueueAddToFront);
UnitIssueOrder(lv_image, Order(AbilityCommand("SamuroIllusionMasterDummy", 0)), c_orderQueueAddToFront);
UnitSelect(libGame_gv_players[lv_thisPlayer].lv_heroUnit, lv_thisPlayer, true);
return true;
}
//--------------------------------------------------------------------------------------------------
void libHSAM_gt_SamuroMirrorImageSwap_Init () {
libHSAM_gt_SamuroMirrorImageSwap = TriggerCreate("libHSAM_gt_SamuroMirrorImageSwap_Func");
TriggerEnable(libHSAM_gt_SamuroMirrorImageSwap, false);
TriggerAddEventPlayerEffectUsed(libHSAM_gt_SamuroMirrorImageSwap, c_playerAny, "SamuroIllusionMasterInitalSet");
}
//--------------------------------------------------------------------------------------------------
// Trigger: Samuro - Mirror Image Mount/Dismount/Port
//--------------------------------------------------------------------------------------------------
bool libHSAM_gt_SamuroMirrorImageMountDismountPort_Func (bool testConds, bool runActions) {
// Variable Declarations
unit lv_itUnit;
// Automatic Variable Declarations
unitgroup auto7FDF9108_g;
int auto7FDF9108_u;
// Variable Initialization
// Conditions
if (testConds) {
if (!((UnitGetType(EventUnit()) == "HeroSamuro"))) {
return false;
}
if (!((UnitGroupHasUnit(UnitGroupSelected(EventPlayer()), EventUnit()) == true))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
auto7FDF9108_g = UnitGroupSelected(EventPlayer());
auto7FDF9108_u = UnitGroupCount(auto7FDF9108_g, c_unitCountAll);
for (;; auto7FDF9108_u -= 1) {
lv_itUnit = UnitGroupUnitFromEnd(auto7FDF9108_g, auto7FDF9108_u);
if (lv_itUnit == null) { break; }
if ((lv_itUnit != EventUnit())) {
UnitIssueOrder(lv_itUnit, Order(EventUnitAbility()), c_orderQueueReplace);
}
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHSAM_gt_SamuroMirrorImageMountDismountPort_Init () {
libHSAM_gt_SamuroMirrorImageMountDismountPort = TriggerCreate("libHSAM_gt_SamuroMirrorImageMountDismountPort_Func");
TriggerEnable(libHSAM_gt_SamuroMirrorImageMountDismountPort, false);
TriggerAddEventUnitAbility(libHSAM_gt_SamuroMirrorImageMountDismountPort, null, AbilityCommand("Hearthstone", 0), c_abilEffectStageCast, false);
TriggerAddEventUnitAbility(libHSAM_gt_SamuroMirrorImageMountDismountPort, null, AbilityCommand("Mount", 0), c_abilEffectStageCast, false);
TriggerAddEventUnitAbility(libHSAM_gt_SamuroMirrorImageMountDismountPort, null, AbilityCommand("Dismount", 0), c_abilEffectStageCast, false);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Samuro - Mirror Image Created
//--------------------------------------------------------------------------------------------------
bool libHSAM_gt_SamuroMirrorImageCreated_Func (bool testConds, bool runActions) {
// Variable Declarations
int lv_wayOfIllusionTokenCount;
int lv_itCount;
unit lv_mirrorImage;
unit lv_samuro;
int lv_samuroLevel;
int lv_samuroPlayer;
int lv_itAbility;
string lv_abilLink;
string lv_cooldownLink;
order lv_toggleOrder;
int lv_itItem;
// Automatic Variable Declarations
unitgroup auto818C40E4_g;
int auto818C40E4_u;
unit auto818C40E4_var;
const int autoA90B362B_ae = libCore_gv_dataHeroesMaxBasicAbilitiesPerHero;
const int autoA90B362B_ai = 1;
// Variable Initialization
lv_mirrorImage = EventUnitCreatedUnit();
lv_cooldownLink = "";
// Conditions
if (testConds) {
if (!((UnitGetType(lv_mirrorImage) == "SamuroMirrorImage"))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
lv_samuroPlayer = UnitGetOwner(lv_mirrorImage);
if ((UnitGetType(libGame_gv_players[lv_samuroPlayer].lv_heroUnit) == "HeroAbathur")) {
lv_samuro = libGame_gv_players[lv_samuroPlayer].lv_activeVehicle;
}
else {
lv_samuro = libGame_gv_players[lv_samuroPlayer].lv_heroUnit;
}
lv_samuroLevel = libGame_gf_GetCustomValueLevelofHeroUnit(lv_samuro);
UnitBehaviorAdd(lv_mirrorImage, "Level", libGame_gv_players[UnitGetOwner(lv_samuro)].lv_heroUnit, UnitBehaviorCount(lv_samuro, "Level"));
UnitBehaviorAdd(lv_mirrorImage, "Ultimate1Unlocked", libGame_gv_players[lv_samuroPlayer].lv_heroUnit, UnitBehaviorCount(lv_samuro, "Ultimate1Unlocked"));
UnitBehaviorAdd(lv_mirrorImage, "Ultimate2Unlocked", libGame_gv_players[lv_samuroPlayer].lv_heroUnit, UnitBehaviorCount(lv_samuro, "Ultimate2Unlocked"));
if ((UnitGetType(libGame_gv_players[lv_samuroPlayer].lv_heroUnit) == "HeroAbathur")) {
UnitBehaviorAdd(lv_mirrorImage, "UltimateEvolutionAlternateHero", lv_samuro, 1);
UnitBehaviorAdd(lv_mirrorImage, "AbathurUltimateEvolutionCleanupTarget", lv_samuro, 1);
}
UnitXPAddXP(lv_mirrorImage, null, libCore_gf_GetTotalXPForLevel(lv_samuroLevel));
libHSAM_gf_SamuroMirrorImagesTransferDurations(lv_samuro, lv_mirrorImage);
libUIUI_gf_UIUnitStatusFramesUpdateUnitStatusFramesForUnit(lv_samuroPlayer, lv_mirrorImage);
UnitGroupAdd(libGame_gv_players[lv_samuroPlayer].lv_heroUnitGroup, lv_mirrorImage);
UnitBehaviorAdd(lv_mirrorImage, "MapMechanicStack", libGame_gv_players[lv_samuroPlayer].lv_heroUnit, UnitBehaviorCount(lv_samuro, "MapMechanicStack"));
UnitBehaviorAdd(lv_mirrorImage, "HasMapMechanicTargetAbility", libGame_gv_players[lv_samuroPlayer].lv_heroUnit, UnitBehaviorCount(lv_samuro, "HasMapMechanicTargetAbility"));
UnitBehaviorAdd(lv_mirrorImage, "HasMapMechanicTargetAbility2", libGame_gv_players[lv_samuroPlayer].lv_heroUnit, UnitBehaviorCount(lv_samuro, "HasMapMechanicTargetAbility2"));
UnitBehaviorAdd(lv_mirrorImage, "HasMapMechanicInstantAbility", libGame_gv_players[lv_samuroPlayer].lv_heroUnit, UnitBehaviorCount(lv_samuro, "HasMapMechanicInstantAbility"));
UnitBehaviorAdd(lv_mirrorImage, "HasMapMechanicInstantAbility1", libGame_gv_players[lv_samuroPlayer].lv_heroUnit, UnitBehaviorCount(lv_samuro, "HasMapMechanicInstantAbility1"));
UnitBehaviorAdd(lv_mirrorImage, "HasMapMechanicInstantAbility2", libGame_gv_players[lv_samuroPlayer].lv_heroUnit, UnitBehaviorCount(lv_samuro, "HasMapMechanicInstantAbility2"));
UnitGroupAdd(libHSAM_gv_mirrorImageUnitGroup[lv_samuroPlayer], lv_mirrorImage);
if ((UnitGroupCount(libHSAM_gv_mirrorImageUnitGroup[lv_samuroPlayer], c_unitCountAlive) > 2)) {
auto818C40E4_g = libHSAM_gv_mirrorImageUnitGroup[lv_samuroPlayer];
auto818C40E4_u = UnitGroupCount(auto818C40E4_g, c_unitCountAll);
for (;; auto818C40E4_u -= 1) {
auto818C40E4_var = UnitGroupUnitFromEnd(auto818C40E4_g, auto818C40E4_u);
if (auto818C40E4_var == null) { break; }
if ((UnitIsAlive(auto818C40E4_var) == true)) {
UnitKill(auto818C40E4_var);
break;
}
}
}
if ((PlayerHasTalent(lv_samuroPlayer, "SamuroHeroicAbilityIllusionMaster") == true)) {
UnitControlGroupAddUnit(lv_samuroPlayer, 4, lv_mirrorImage);
if ((UnitGroupCount(libHSAM_gv_mirrorImageUnitGroup2[lv_samuroPlayer], c_unitCountAlive) > 0)) {
UnitGroupAdd(libHSAM_gv_mirrorImageUnitGroup3[lv_samuroPlayer], lv_mirrorImage);
UnitControlGroupAddUnit(lv_samuroPlayer, 3, lv_mirrorImage);
UnitBehaviorAdd(lv_mirrorImage, "SamuroMirrorImage2Dummy", lv_samuro, 1);
libNtve_gf_SendActorMessageToUnit(lv_mirrorImage, "SetUnitIcon Assets\\Textures\\storm_ui_icon_samuro_selectmirror2.dds");
}
else {
UnitGroupAdd(libHSAM_gv_mirrorImageUnitGroup2[lv_samuroPlayer], lv_mirrorImage);
UnitControlGroupAddUnit(lv_samuroPlayer, 2, lv_mirrorImage);
UnitBehaviorAdd(lv_mirrorImage, "SamuroMirrorImage1Dummy", lv_samuro, 1);
}
}
lv_itAbility = 1;
for ( ; ( (autoA90B362B_ai >= 0 && lv_itAbility <= autoA90B362B_ae) || (autoA90B362B_ai < 0 && lv_itAbility >= autoA90B362B_ae) ) ; lv_itAbility += autoA90B362B_ai ) {
lv_abilLink = libGame_gv_players[lv_samuroPlayer].lv_heroData.lv_abilities[lv_itAbility].lv_ability;
lv_cooldownLink = CatalogFieldValueGet(c_gameCatalogAbil, lv_abilLink, "Cost[" + IntToString(0) + "].Cooldown.Link", lv_samuroPlayer);
UnitModifyCooldown(lv_mirrorImage, lv_cooldownLink, UnitGetCooldown(lv_samuro, lv_cooldownLink), c_cooldownOperationSet);
}
if ((EventUnitCreatedAbil() == "SamuroWindwalk")) {
libHSAM_gf_SamuroKawarimi(lv_mirrorImage);
}
if ((PlayerHasTalent(lv_samuroPlayer, "SamuroHeroicAbilityIllusionMaster") == true) && (UnitBehaviorCount(lv_samuro, "SamuroIllusionMasterToggleAI") == 1)) {
UnitBehaviorAdd(lv_mirrorImage, "MirrorImageAIToggledOff", lv_mirrorImage, 1);
}
else {
libHSAM_gf_SamuroMirrorImageAIActivationRetainOrderDelay(lv_mirrorImage);
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHSAM_gt_SamuroMirrorImageCreated_Init () {
libHSAM_gt_SamuroMirrorImageCreated = TriggerCreate("libHSAM_gt_SamuroMirrorImageCreated_Func");
TriggerEnable(libHSAM_gt_SamuroMirrorImageCreated, false);
TriggerAddEventUnitCreated(libHSAM_gt_SamuroMirrorImageCreated, null, null, null);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Samuro - Mirror Image Dies
//--------------------------------------------------------------------------------------------------
bool libHSAM_gt_SamuroMirrorImageDies_Func (bool testConds, bool runActions) {
// Variable Declarations
unit lv_mirrorImage;
unitgroup lv_selectedUnits;
int lv_samuroPlayer;
// Automatic Variable Declarations
// Variable Initialization
lv_selectedUnits = UnitGroupEmpty();
// Conditions
if (testConds) {
if (!((UnitGetType(EventUnit()) == "SamuroMirrorImage"))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
lv_samuroPlayer = UnitGetOwner(EventUnit());
lv_selectedUnits = UnitGroupSelected(lv_samuroPlayer);
lv_mirrorImage = EventUnit();
UnitCreateEffectUnit(libGame_gv_players[lv_samuroPlayer].lv_heroUnit, "SamuroMirrorImageRemoveCountStacks", libGame_gv_players[lv_samuroPlayer].lv_heroUnit);
libAIAI_gf_MinionAIUnhookUnitFromMinionAI(lv_mirrorImage);
if ((UnitIsSelected(libGame_gv_players[lv_samuroPlayer].lv_heroUnit, lv_samuroPlayer) == false) && ((UnitGroupCount(UnitGroupSelected(lv_samuroPlayer), c_unitCountAlive) == 0) || (UnitGroupCount(libHSAM_gv_mirrorImageUnitGroup[lv_samuroPlayer], c_unitCountAlive) == 0))) {
if ((UnitGetType(libGame_gv_players[lv_samuroPlayer].lv_activeVehicle) == "")) {
UnitGroupSelect(lv_selectedUnits, lv_samuroPlayer, false);
UnitSelect(libGame_gv_players[lv_samuroPlayer].lv_heroUnit, lv_samuroPlayer, true);
}
else {
UnitGroupSelect(lv_selectedUnits, lv_samuroPlayer, false);
UnitSelect(libGame_gv_players[lv_samuroPlayer].lv_activeVehicle, lv_samuroPlayer, true);
}
}
UnitGroupRemove(libHSAM_gv_mirrorImageUnitGroup[lv_samuroPlayer], lv_mirrorImage);
libUIUI_gf_UIUnitStatusFramesRemoveUnitfromUnitStatusFrameHookup(lv_samuroPlayer, lv_mirrorImage);
AIRemovePlayerUnit(lv_mirrorImage);
UnitRemove(lv_mirrorImage);
return true;
}
//--------------------------------------------------------------------------------------------------
void libHSAM_gt_SamuroMirrorImageDies_Init () {
libHSAM_gt_SamuroMirrorImageDies = TriggerCreate("libHSAM_gt_SamuroMirrorImageDies_Func");
TriggerEnable(libHSAM_gt_SamuroMirrorImageDies, false);
TriggerAddEventUnitDied(libHSAM_gt_SamuroMirrorImageDies, null);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Samuro - Mirror Image Controller
//--------------------------------------------------------------------------------------------------
bool libHSAM_gt_SamuroMirrorImageController_Func (bool testConds, bool runActions) {
// Variable Declarations
int lv_thisPlayer;
unit lv_thisCreatedUnit;
unit lv_killUnit;
// Automatic Variable Declarations
// Variable Initialization
// Conditions
if (testConds) {
if (!((UnitGetType(EventUnitCreatedUnit()) == "SamuroMirrorImage"))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
lv_thisPlayer = EventPlayer();
lv_thisCreatedUnit = EventUnitCreatedUnit();
UnitGroupAdd(libHSAM_gv_mirrorImageUnitGroup[lv_thisPlayer], lv_thisCreatedUnit);
UnitGroupAdd(libGame_gv_players[lv_thisPlayer].lv_altClickPartyFrameAnnouncementUnitGroup, lv_thisCreatedUnit);
if ((UnitGroupCount(libHSAM_gv_mirrorImageUnitGroup[lv_thisPlayer], c_unitCountAlive) > 2)) {
UnitKill(UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup[lv_thisPlayer], 1));
UnitGroupRemove(libHSAM_gv_mirrorImageUnitGroup[lv_thisPlayer], UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup[lv_thisPlayer], 1));
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHSAM_gt_SamuroMirrorImageController_Init () {
libHSAM_gt_SamuroMirrorImageController = TriggerCreate("libHSAM_gt_SamuroMirrorImageController_Func");
TriggerEnable(libHSAM_gt_SamuroMirrorImageController, false);
TriggerAddEventUnitCreated(libHSAM_gt_SamuroMirrorImageController, null, null, null);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Samuro - Mirror Image Illusion Master AI Toggle On
//--------------------------------------------------------------------------------------------------
bool libHSAM_gt_SamuroMirrorImageIllusionMasterAIToggleOn_Func (bool testConds, bool runActions) {
// Variable Declarations
int lv_samuroPlayer;
unit lv_itSamuroUnit;
// Automatic Variable Declarations
unitgroup auto7AB18358_g;
int auto7AB18358_u;
// Variable Initialization
lv_samuroPlayer = UnitGetOwner(EventUnit());
// Conditions
if (testConds) {
if (!((UnitBehaviorCount(EventUnit(), "SamuroIllusionMasterToggleAI") == 0))) {
return false;
}
if (!((lv_samuroPlayer <= libCore_gv_bALMaxPlayers))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
auto7AB18358_g = libHSAM_gv_mirrorImageUnitGroup[lv_samuroPlayer];
auto7AB18358_u = UnitGroupCount(auto7AB18358_g, c_unitCountAll);
for (;; auto7AB18358_u -= 1) {
lv_itSamuroUnit = UnitGroupUnitFromEnd(auto7AB18358_g, auto7AB18358_u);
if (lv_itSamuroUnit == null) { break; }
UnitBehaviorRemove(lv_itSamuroUnit, "MirrorImageAIToggledOff", 1);
libHSAM_gf_SamuroMirrorImageAIActivationRetainOrderDelay(lv_itSamuroUnit);
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHSAM_gt_SamuroMirrorImageIllusionMasterAIToggleOn_Init () {
libHSAM_gt_SamuroMirrorImageIllusionMasterAIToggleOn = TriggerCreate("libHSAM_gt_SamuroMirrorImageIllusionMasterAIToggleOn_Func");
TriggerEnable(libHSAM_gt_SamuroMirrorImageIllusionMasterAIToggleOn, false);
TriggerAddEventUnitAbility(libHSAM_gt_SamuroMirrorImageIllusionMasterAIToggleOn, null, AbilityCommand("SamuroIllusionMasterToggleAI", 1), c_abilBehaviorStageUntoggled, true);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Samuro - Mirror Image Illusion Master AI Toggle Off
//--------------------------------------------------------------------------------------------------
bool libHSAM_gt_SamuroMirrorImageIllusionMasterAIToggleOff_Func (bool testConds, bool runActions) {
// Variable Declarations
int lv_samuroPlayer;
unit lv_itSamuroUnit;
// Automatic Variable Declarations
unitgroup autoB8A246BB_g;
int autoB8A246BB_u;
// Variable Initialization
lv_samuroPlayer = UnitGetOwner(EventUnit());
// Conditions
if (testConds) {
if (!((UnitBehaviorCount(EventUnit(), "SamuroIllusionMasterToggleAI") == 1))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
autoB8A246BB_g = libHSAM_gv_mirrorImageUnitGroup[lv_samuroPlayer];
autoB8A246BB_u = UnitGroupCount(autoB8A246BB_g, c_unitCountAll);
for (;; autoB8A246BB_u -= 1) {
lv_itSamuroUnit = UnitGroupUnitFromEnd(autoB8A246BB_g, autoB8A246BB_u);
if (lv_itSamuroUnit == null) { break; }
UnitBehaviorAdd(lv_itSamuroUnit, "MirrorImageAIToggledOff", lv_itSamuroUnit, 1);
UnitDestroyAIThinkTree(lv_itSamuroUnit);
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHSAM_gt_SamuroMirrorImageIllusionMasterAIToggleOff_Init () {
libHSAM_gt_SamuroMirrorImageIllusionMasterAIToggleOff = TriggerCreate("libHSAM_gt_SamuroMirrorImageIllusionMasterAIToggleOff_Func");
TriggerEnable(libHSAM_gt_SamuroMirrorImageIllusionMasterAIToggleOff, false);
TriggerAddEventUnitAbility(libHSAM_gt_SamuroMirrorImageIllusionMasterAIToggleOff, null, AbilityCommand("SamuroIllusionMasterToggleAI", 0), c_abilBehaviorStageToggled, true);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Samuro - Mirror Image Attack Order Redirect AI
//--------------------------------------------------------------------------------------------------
bool libHSAM_gt_SamuroMirrorImageAttackOrderRedirectAI_Func (bool testConds, bool runActions) {
// Variable Declarations
int lv_samuroPlayer;
unit lv_itUnit;
// Automatic Variable Declarations
unitgroup auto01A4FFB0_g;
int auto01A4FFB0_u;
// Variable Initialization
lv_samuroPlayer = UnitGetOwner(EventUnitTarget());
// Conditions
if (testConds) {
if (!((PlayerHasTalent(lv_samuroPlayer, "SamuroHeroicAbilityIllusionMaster") == false))) {
return false;
}
if (!((UnitGetType(EventUnitTarget()) == "HeroSamuro"))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
auto01A4FFB0_g = libHSAM_gv_mirrorImageUnitGroup[lv_samuroPlayer];
auto01A4FFB0_u = UnitGroupCount(auto01A4FFB0_g, c_unitCountAll);
for (;; auto01A4FFB0_u -= 1) {
lv_itUnit = UnitGroupUnitFromEnd(auto01A4FFB0_g, auto01A4FFB0_u);
if (lv_itUnit == null) { break; }
if ((OrderGetAbilityCommand(UnitOrder(lv_itUnit, 0)) != AbilityCommand("attack", 0)) && ((UnitTypeTestAttribute(UnitGetType(EventUnit()), c_unitAttributeCreep) == true) || (UnitBehaviorDuration(lv_itUnit, "SamuroMirrorImageTimedLife") >= 9.0)) && (DistanceBetweenPoints(UnitGetPosition(EventUnitTarget()), UnitGetPosition(lv_itUnit)) < 15.0) && (UnitHasBehavior2(lv_itUnit, "SylvanasMindControlTarget") == false)) {
UnitRestartAIThinkTree(lv_itUnit);
}
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHSAM_gt_SamuroMirrorImageAttackOrderRedirectAI_Init () {
libHSAM_gt_SamuroMirrorImageAttackOrderRedirectAI = TriggerCreate("libHSAM_gt_SamuroMirrorImageAttackOrderRedirectAI_Func");
TriggerEnable(libHSAM_gt_SamuroMirrorImageAttackOrderRedirectAI, false);
TriggerAddEventUnitAttacked2(libHSAM_gt_SamuroMirrorImageAttackOrderRedirectAI, null, "SamuroWeapon");
}
//--------------------------------------------------------------------------------------------------
// Trigger: Samuro - Mirror Image Damage Taken Duplication
//--------------------------------------------------------------------------------------------------
bool libHSAM_gt_SamuroMirrorImageDamageTakenDuplication_Func (bool testConds, bool runActions) {
// Variable Declarations
fixed lv_damage;
fixed lv_threeBladeStyleDamage;
unit lv_image;
int lv_imageOwner;
unit lv_caster;
// Automatic Variable Declarations
// Variable Initialization
lv_damage = (EventUnitDamageAmount() + EventUnitDamageBehaviorShield());
lv_threeBladeStyleDamage = (lv_damage / 2.0);
lv_image = EventUnit();
lv_imageOwner = UnitGetOwner(lv_image);
lv_caster = EventUnitDamageSourceUnit();
// Conditions
if (testConds) {
if (!((UnitGetType(lv_image) == "SamuroMirrorImage"))) {
return false;
}
if (!((EventUnitDamageEffect() != "HeroGenericFakeHeroDuplicationDamage"))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
if ((PlayerHasTalent(lv_imageOwner, "SamuroThreeBladeStyle") == false)) {
if ((UnitIsValid(libGame_gv_teams[libGame_gf_EnemyTeamNumberOfPlayer(lv_imageOwner)].lv_core) == true)) {
UnitDamage(libGame_gv_teams[libGame_gf_EnemyTeamNumberOfPlayer(lv_imageOwner)].lv_core, "HeroGenericFakeHeroDuplicationDamage", lv_image, lv_damage);
}
else {
UnitDamage(lv_caster, "HeroGenericFakeHeroDuplicationDamage", lv_image, lv_damage);
}
}
else {
if ((UnitIsValid(libGame_gv_teams[libGame_gf_EnemyTeamNumberOfPlayer(lv_imageOwner)].lv_core) == true)) {
UnitDamage(libGame_gv_teams[libGame_gf_EnemyTeamNumberOfPlayer(lv_imageOwner)].lv_core, "HeroGenericFakeHeroDuplicationDamage", lv_image, lv_threeBladeStyleDamage);
}
else {
UnitDamage(lv_caster, "HeroGenericFakeHeroDuplicationDamage", lv_image, lv_threeBladeStyleDamage);
}
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHSAM_gt_SamuroMirrorImageDamageTakenDuplication_Init () {
libHSAM_gt_SamuroMirrorImageDamageTakenDuplication = TriggerCreate("libHSAM_gt_SamuroMirrorImageDamageTakenDuplication_Func");
TriggerEnable(libHSAM_gt_SamuroMirrorImageDamageTakenDuplication, false);
TriggerAddEventUnitDamaged(libHSAM_gt_SamuroMirrorImageDamageTakenDuplication, UnitRefFromUnit(UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup[1], 1)), c_unitDamageTypeAny, c_unitDamageNonFatal, null);
TriggerAddEventUnitDamaged(libHSAM_gt_SamuroMirrorImageDamageTakenDuplication, UnitRefFromUnit(UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup[1], 2)), c_unitDamageTypeAny, c_unitDamageNonFatal, null);
TriggerAddEventUnitDamaged(libHSAM_gt_SamuroMirrorImageDamageTakenDuplication, UnitRefFromUnit(UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup[2], 1)), c_unitDamageTypeAny, c_unitDamageNonFatal, null);
TriggerAddEventUnitDamaged(libHSAM_gt_SamuroMirrorImageDamageTakenDuplication, UnitRefFromUnit(UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup[2], 2)), c_unitDamageTypeAny, c_unitDamageNonFatal, null);
TriggerAddEventUnitDamaged(libHSAM_gt_SamuroMirrorImageDamageTakenDuplication, UnitRefFromUnit(UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup[3], 1)), c_unitDamageTypeAny, c_unitDamageNonFatal, null);
TriggerAddEventUnitDamaged(libHSAM_gt_SamuroMirrorImageDamageTakenDuplication, UnitRefFromUnit(UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup[3], 2)), c_unitDamageTypeAny, c_unitDamageNonFatal, null);
TriggerAddEventUnitDamaged(libHSAM_gt_SamuroMirrorImageDamageTakenDuplication, UnitRefFromUnit(UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup[4], 1)), c_unitDamageTypeAny, c_unitDamageNonFatal, null);
TriggerAddEventUnitDamaged(libHSAM_gt_SamuroMirrorImageDamageTakenDuplication, UnitRefFromUnit(UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup[4], 2)), c_unitDamageTypeAny, c_unitDamageNonFatal, null);
TriggerAddEventUnitDamaged(libHSAM_gt_SamuroMirrorImageDamageTakenDuplication, UnitRefFromUnit(UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup[5], 1)), c_unitDamageTypeAny, c_unitDamageNonFatal, null);
TriggerAddEventUnitDamaged(libHSAM_gt_SamuroMirrorImageDamageTakenDuplication, UnitRefFromUnit(UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup[5], 2)), c_unitDamageTypeAny, c_unitDamageNonFatal, null);
TriggerAddEventUnitDamaged(libHSAM_gt_SamuroMirrorImageDamageTakenDuplication, UnitRefFromUnit(UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup[6], 1)), c_unitDamageTypeAny, c_unitDamageNonFatal, null);
TriggerAddEventUnitDamaged(libHSAM_gt_SamuroMirrorImageDamageTakenDuplication, UnitRefFromUnit(UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup[6], 2)), c_unitDamageTypeAny, c_unitDamageNonFatal, null);
TriggerAddEventUnitDamaged(libHSAM_gt_SamuroMirrorImageDamageTakenDuplication, UnitRefFromUnit(UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup[7], 1)), c_unitDamageTypeAny, c_unitDamageNonFatal, null);
TriggerAddEventUnitDamaged(libHSAM_gt_SamuroMirrorImageDamageTakenDuplication, UnitRefFromUnit(UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup[7], 2)), c_unitDamageTypeAny, c_unitDamageNonFatal, null);
TriggerAddEventUnitDamaged(libHSAM_gt_SamuroMirrorImageDamageTakenDuplication, UnitRefFromUnit(UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup[8], 1)), c_unitDamageTypeAny, c_unitDamageNonFatal, null);
TriggerAddEventUnitDamaged(libHSAM_gt_SamuroMirrorImageDamageTakenDuplication, UnitRefFromUnit(UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup[8], 2)), c_unitDamageTypeAny, c_unitDamageNonFatal, null);
TriggerAddEventUnitDamaged(libHSAM_gt_SamuroMirrorImageDamageTakenDuplication, UnitRefFromUnit(UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup[9], 1)), c_unitDamageTypeAny, c_unitDamageNonFatal, null);
TriggerAddEventUnitDamaged(libHSAM_gt_SamuroMirrorImageDamageTakenDuplication, UnitRefFromUnit(UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup[9], 2)), c_unitDamageTypeAny, c_unitDamageNonFatal, null);
TriggerAddEventUnitDamaged(libHSAM_gt_SamuroMirrorImageDamageTakenDuplication, UnitRefFromUnit(UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup[10], 1)), c_unitDamageTypeAny, c_unitDamageNonFatal, null);
TriggerAddEventUnitDamaged(libHSAM_gt_SamuroMirrorImageDamageTakenDuplication, UnitRefFromUnit(UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup[10], 2)), c_unitDamageTypeAny, c_unitDamageNonFatal, null);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Samuro - Critical Strike
//--------------------------------------------------------------------------------------------------
bool libHSAM_gt_SamuroCriticalStrike_Func (bool testConds, bool runActions) {
// Variable Declarations
int lv_samuroPlayer;
string lv_criticalStrikeCooldownLink;
unit lv_itUnit;
// Automatic Variable Declarations
unitgroup autoAD29B92A_g;
int autoAD29B92A_u;
// Variable Initialization
lv_criticalStrikeCooldownLink = "";
// Actions
if (!runActions) {
return true;
}
lv_samuroPlayer = UnitGetOwner(EventUnit());
autoAD29B92A_g = libGame_gv_players[lv_samuroPlayer].lv_heroUnitGroup;
autoAD29B92A_u = UnitGroupCount(autoAD29B92A_g, c_unitCountAll);
for (;; autoAD29B92A_u -= 1) {
lv_itUnit = UnitGroupUnitFromEnd(autoAD29B92A_g, autoAD29B92A_u);
if (lv_itUnit == null) { break; }
if ((lv_itUnit != EventUnit())) {
lv_criticalStrikeCooldownLink = CatalogFieldValueGet(c_gameCatalogAbil, "SamuroCriticalStrike", "Cost[" + IntToString(0) + "].Cooldown.Link", lv_samuroPlayer);
libNtve_gf_UnitRemoveCooldown(lv_itUnit, lv_criticalStrikeCooldownLink);
UnitIssueOrder(lv_itUnit, Order(AbilityCommand("SamuroCriticalStrike", 0)), c_orderQueueReplace);
}
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHSAM_gt_SamuroCriticalStrike_Init () {
libHSAM_gt_SamuroCriticalStrike = TriggerCreate("libHSAM_gt_SamuroCriticalStrike_Func");
TriggerEnable(libHSAM_gt_SamuroCriticalStrike, false);
TriggerAddEventUnitAbility(libHSAM_gt_SamuroCriticalStrike, null, AbilityCommand("SamuroCriticalStrikeDummy", 0), c_abilEffectStageCast, false);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Samuro - Bladestorm
//--------------------------------------------------------------------------------------------------
bool libHSAM_gt_SamuroBladestorm_Func (bool testConds, bool runActions) {
// Variable Declarations
int lv_samuroPlayer;
string lv_bladestormCooldownLink;
unit lv_itUnit;
// Automatic Variable Declarations
unitgroup auto022C31C7_g;
int auto022C31C7_u;
unitgroup auto1ACCA2DA_g;
int auto1ACCA2DA_u;
// Variable Initialization
lv_bladestormCooldownLink = "";
// Actions
if (!runActions) {
return true;
}
lv_samuroPlayer = UnitGetOwner(EventUnit());
if ((PlayerHasTalent(lv_samuroPlayer, "SamuroDanceOfDeath") == true) && (EventUnitAbility() == AbilityCommand("SamuroBladeStormDummy", 0))) {
auto1ACCA2DA_g = libGame_gv_players[lv_samuroPlayer].lv_heroUnitGroup;
auto1ACCA2DA_u = UnitGroupCount(auto1ACCA2DA_g, c_unitCountAll);
for (;; auto1ACCA2DA_u -= 1) {
lv_itUnit = UnitGroupUnitFromEnd(auto1ACCA2DA_g, auto1ACCA2DA_u);
if (lv_itUnit == null) { break; }
lv_bladestormCooldownLink = CatalogFieldValueGet(c_gameCatalogAbil, "SamuroBladestorm", "Cost[" + IntToString(0) + "].Cooldown.Link", lv_samuroPlayer);
libNtve_gf_UnitRemoveCooldown(lv_itUnit, lv_bladestormCooldownLink);
UnitIssueOrder(lv_itUnit, Order(AbilityCommand("SamuroBladestorm", 0)), c_orderQueueReplace);
}
}
else {
if ((PlayerHasTalent(lv_samuroPlayer, "SamuroDanceOfDeath") == true) && (EventUnitAbility() == AbilityCommand("SamuroBladestormCancel", 0))) {
auto022C31C7_g = libGame_gv_players[lv_samuroPlayer].lv_heroUnitGroup;
auto022C31C7_u = UnitGroupCount(auto022C31C7_g, c_unitCountAll);
for (;; auto022C31C7_u -= 1) {
lv_itUnit = UnitGroupUnitFromEnd(auto022C31C7_g, auto022C31C7_u);
if (lv_itUnit == null) { break; }
UnitIssueOrder(lv_itUnit, Order(AbilityCommand("SamuroBladestormCancel", 0)), c_orderQueueReplace);
}
}
else {
if ((EventUnitAbility() == AbilityCommand("SamuroBladeStormDummy", 0))) {
UnitIssueOrder(EventUnit(), Order(AbilityCommand("SamuroBladestorm", 0)), c_orderQueueReplace);
}
}
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHSAM_gt_SamuroBladestorm_Init () {
libHSAM_gt_SamuroBladestorm = TriggerCreate("libHSAM_gt_SamuroBladestorm_Func");
TriggerEnable(libHSAM_gt_SamuroBladestorm, false);
TriggerAddEventUnitAbility(libHSAM_gt_SamuroBladestorm, null, AbilityCommand("SamuroBladeStormDummy", 0), c_abilEffectStageCast, false);
TriggerAddEventUnitAbility(libHSAM_gt_SamuroBladestorm, null, AbilityCommand("SamuroBladestormCancel", 0), c_abilEffectStageCast, false);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Samuro - Way of Illusion
//--------------------------------------------------------------------------------------------------
bool libHSAM_gt_SamuroWayofIllusion_Func (bool testConds, bool runActions) {
// Variable Declarations
unit lv_samuro;
unit lv_mirrorImage;
int lv_samuroPlayer;
// Automatic Variable Declarations
unitgroup auto687B0F4F_g;
int auto687B0F4F_u;
unit auto687B0F4F_var;
// Variable Initialization
lv_mirrorImage = UnitBehaviorEffectUnit(EventUnit(), "SamuroCriticalStrikeDummyBehavior", c_effectUnitCaster, 0);
lv_samuroPlayer = UnitGetOwner(UnitBehaviorEffectUnit(EventUnit(), "SamuroCriticalStrikeDummyBehavior", c_effectUnitCaster, 0));
// Conditions
if (testConds) {
if (!((UnitGetType(lv_mirrorImage) == "SamuroMirrorImage"))) {
return false;
}
if (!((PlayerHasTalent(lv_samuroPlayer, "SamuroWayOfIllusion") == true))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
lv_samuro = libGame_gv_players[lv_samuroPlayer].lv_heroUnit;
if ((UnitTypeTestAttribute(UnitGetType(UnitBehaviorEffectUnit(EventUnit(), "SamuroCriticalStrikeDummyBehavior", c_effectUnitTarget, 0)), c_unitAttributeHeroic) == true) && (UnitBehaviorCount(lv_samuro, "SamuroMirrorImageWayOfIllusionQuestToken") < 40)) {
UnitCreateEffectUnit(lv_samuro, "SamuroMirrorImageWayOfIllusionQuestIncrementToken", lv_samuro);
auto687B0F4F_g = libHSAM_gv_mirrorImageUnitGroup[lv_samuroPlayer];
auto687B0F4F_u = UnitGroupCount(auto687B0F4F_g, c_unitCountAll);
for (;; auto687B0F4F_u -= 1) {
auto687B0F4F_var = UnitGroupUnitFromEnd(auto687B0F4F_g, auto687B0F4F_u);
if (auto687B0F4F_var == null) { break; }
UnitCreateEffectUnit(auto687B0F4F_var, "SamuroMirrorImageWayOfIllusionQuestIncrementToken", auto687B0F4F_var);
}
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHSAM_gt_SamuroWayofIllusion_Init () {
libHSAM_gt_SamuroWayofIllusion = TriggerCreate("libHSAM_gt_SamuroWayofIllusion_Func");
TriggerEnable(libHSAM_gt_SamuroWayofIllusion, false);
TriggerAddEventUnitBehaviorChange(libHSAM_gt_SamuroWayofIllusion, null, "SamuroCriticalStrikeDummyBehavior", c_unitBehaviorChangeRefresh);
TriggerAddEventUnitBehaviorChange(libHSAM_gt_SamuroWayofIllusion, null, "SamuroCriticalStrikeDummyBehavior", c_unitBehaviorChangeCreate);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Samuro - Gains Way of Illusion
//--------------------------------------------------------------------------------------------------
bool libHSAM_gt_SamuroGainsWayofIllusion_Func (bool testConds, bool runActions) {
// Variable Declarations
int lv_samuroPlayer;
// Automatic Variable Declarations
unitgroup auto6AE13599_g;
int auto6AE13599_u;
unit auto6AE13599_var;
// Variable Initialization
lv_samuroPlayer = libGame_gf_HeroGainTalentPlayer();
// Conditions
if (testConds) {
if (!((libGame_gf_HeroGainTalentGainedTalent() == "SamuroWayOfIllusion"))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
auto6AE13599_g = libHSAM_gv_mirrorImageUnitGroup[lv_samuroPlayer];
auto6AE13599_u = UnitGroupCount(auto6AE13599_g, c_unitCountAll);
for (;; auto6AE13599_u -= 1) {
auto6AE13599_var = UnitGroupUnitFromEnd(auto6AE13599_g, auto6AE13599_u);
if (auto6AE13599_var == null) { break; }
UnitBehaviorAdd(auto6AE13599_var, "SamuroMirrorImageWayOfIllusionQuestTokenClone", auto6AE13599_var, 1);
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHSAM_gt_SamuroGainsWayofIllusion_Init () {
libHSAM_gt_SamuroGainsWayofIllusion = TriggerCreate("libHSAM_gt_SamuroGainsWayofIllusion_Func");
TriggerEnable(libHSAM_gt_SamuroGainsWayofIllusion, false);
libGame_gf_HeroGainTalent(libHSAM_gt_SamuroGainsWayofIllusion);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Samuro - Loses Way of Illusion
//--------------------------------------------------------------------------------------------------
bool libHSAM_gt_SamuroLosesWayofIllusion_Func (bool testConds, bool runActions) {
// Variable Declarations
int lv_samuroPlayer;
// Automatic Variable Declarations
unitgroup auto9977816B_g;
int auto9977816B_u;
unit auto9977816B_var;
// Variable Initialization
lv_samuroPlayer = libGame_gf_HeroRespecsTalentsPlayer();
// Conditions
if (testConds) {
if (!((UnitGetType(libGame_gv_players[lv_samuroPlayer].lv_heroUnit) == "HeroSamuro"))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
auto9977816B_g = libHSAM_gv_mirrorImageUnitGroup[lv_samuroPlayer];
auto9977816B_u = UnitGroupCount(auto9977816B_g, c_unitCountAll);
for (;; auto9977816B_u -= 1) {
auto9977816B_var = UnitGroupUnitFromEnd(auto9977816B_g, auto9977816B_u);
if (auto9977816B_var == null) { break; }
UnitBehaviorRemove(auto9977816B_var, "SamuroMirrorImageWayOfIllusionQuestTokenClone", 1);
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHSAM_gt_SamuroLosesWayofIllusion_Init () {
libHSAM_gt_SamuroLosesWayofIllusion = TriggerCreate("libHSAM_gt_SamuroLosesWayofIllusion_Func");
TriggerEnable(libHSAM_gt_SamuroLosesWayofIllusion, false);
libGame_gf_HeroRespecsTalents(libHSAM_gt_SamuroLosesWayofIllusion);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Samuro - Gains Three Blade Style Talent
//--------------------------------------------------------------------------------------------------
bool libHSAM_gt_SamuroGainsThreeBladeStyleTalent_Func (bool testConds, bool runActions) {
// Variable Declarations
int lv_samuroPlayer;
// Automatic Variable Declarations
unitgroup auto7FADCF0D_g;
int auto7FADCF0D_u;
unit auto7FADCF0D_var;
// Variable Initialization
lv_samuroPlayer = libGame_gf_HeroGainTalentPlayer();
// Conditions
if (testConds) {
if (!((libGame_gf_HeroGainTalentGainedTalent() == "SamuroThreeBladeStyle"))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
auto7FADCF0D_g = libHSAM_gv_mirrorImageUnitGroup[lv_samuroPlayer];
auto7FADCF0D_u = UnitGroupCount(auto7FADCF0D_g, c_unitCountAll);
for (;; auto7FADCF0D_u -= 1) {
auto7FADCF0D_var = UnitGroupUnitFromEnd(auto7FADCF0D_g, auto7FADCF0D_u);
if (auto7FADCF0D_var == null) { break; }
UnitSetPropertyFixed(auto7FADCF0D_var, c_unitPropLifeMax, UnitGetPropertyFixed(libGame_gv_players[lv_samuroPlayer].lv_heroUnit, c_unitPropLifeMax, c_unitPropCurrent));
UnitCreateEffectUnit(libGame_gv_players[lv_samuroPlayer].lv_heroUnit, "SamuroIllusionMasterThreeBladeStyleRemovedTimedLifeBehavior", auto7FADCF0D_var);
UnitCreateEffectUnit(libGame_gv_players[lv_samuroPlayer].lv_heroUnit, "SamuroIllusionMasterThreeBladeStyleApplyTimedLifeBehaviorRedirectTarget", auto7FADCF0D_var);
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHSAM_gt_SamuroGainsThreeBladeStyleTalent_Init () {
libHSAM_gt_SamuroGainsThreeBladeStyleTalent = TriggerCreate("libHSAM_gt_SamuroGainsThreeBladeStyleTalent_Func");
TriggerEnable(libHSAM_gt_SamuroGainsThreeBladeStyleTalent, false);
libGame_gf_HeroGainTalent(libHSAM_gt_SamuroGainsThreeBladeStyleTalent);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Samuro - Gains Crushing Blow Talent
//--------------------------------------------------------------------------------------------------
bool libHSAM_gt_SamuroGainsCrushingBlowTalent_Func (bool testConds, bool runActions) {
// Variable Declarations
int lv_samuroPlayer;
// Automatic Variable Declarations
unitgroup autoAC9E7C73_g;
int autoAC9E7C73_u;
unit autoAC9E7C73_var;
// Variable Initialization
lv_samuroPlayer = libGame_gf_HeroGainTalentPlayer();
// Conditions
if (testConds) {
if (!((libGame_gf_HeroGainTalentGainedTalent() == "SamuroCrushingBlow"))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
autoAC9E7C73_g = libHSAM_gv_mirrorImageUnitGroup[lv_samuroPlayer];
autoAC9E7C73_u = UnitGroupCount(autoAC9E7C73_g, c_unitCountAll);
for (;; autoAC9E7C73_u -= 1) {
autoAC9E7C73_var = UnitGroupUnitFromEnd(autoAC9E7C73_g, autoAC9E7C73_u);
if (autoAC9E7C73_var == null) { break; }
UnitBehaviorAdd(autoAC9E7C73_var, "SamuroCriticalStrikeCrushingBlowsCarryBehavior", autoAC9E7C73_var, 1);
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHSAM_gt_SamuroGainsCrushingBlowTalent_Init () {
libHSAM_gt_SamuroGainsCrushingBlowTalent = TriggerCreate("libHSAM_gt_SamuroGainsCrushingBlowTalent_Func");
TriggerEnable(libHSAM_gt_SamuroGainsCrushingBlowTalent, false);
libGame_gf_HeroGainTalent(libHSAM_gt_SamuroGainsCrushingBlowTalent);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Samuro - Mirage
//--------------------------------------------------------------------------------------------------
bool libHSAM_gt_SamuroMirage_Func (bool testConds, bool runActions) {
// Variable Declarations
int lv_thisPlayer;
// Automatic Variable Declarations
unitgroup auto7BD3F063_g;
int auto7BD3F063_u;
unit auto7BD3F063_var;
// Variable Initialization
lv_thisPlayer = UnitGetOwner(EventPlayerEffectUsedUnit(c_effectUnitCaster));
// Conditions
if (testConds) {
if (!((UnitGetType(EventPlayerEffectUsedUnit(c_effectUnitCaster)) == "HeroSamuro"))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
auto7BD3F063_g = libHSAM_gv_mirrorImageUnitGroup[lv_thisPlayer];
auto7BD3F063_u = UnitGroupCount(auto7BD3F063_g, c_unitCountAll);
for (;; auto7BD3F063_u -= 1) {
auto7BD3F063_var = UnitGroupUnitFromEnd(auto7BD3F063_g, auto7BD3F063_u);
if (auto7BD3F063_var == null) { break; }
UnitCreateEffectUnit(auto7BD3F063_var, "SamuroMirrorImageMirageSpellBlockApplyCaster", auto7BD3F063_var);
UnitCreateEffectUnit(auto7BD3F063_var, "SamuroMirrorImageMirageSpellBlockApplyVisual", auto7BD3F063_var);
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHSAM_gt_SamuroMirage_Init () {
libHSAM_gt_SamuroMirage = TriggerCreate("libHSAM_gt_SamuroMirage_Func");
TriggerEnable(libHSAM_gt_SamuroMirage, false);
TriggerAddEventPlayerEffectUsed(libHSAM_gt_SamuroMirage, c_playerAny, "SamuroMirrorImageMirageSpellBlockApplyCaster");
}
//--------------------------------------------------------------------------------------------------
// Trigger: Samuro - Gains R2 Talent
//--------------------------------------------------------------------------------------------------
bool libHSAM_gt_SamuroGainsR2Talent_Func (bool testConds, bool runActions) {
// Variable Declarations
int lv_samuroPlayer;
unit lv_samuro;
unit lv_samuro2;
// Automatic Variable Declarations
unitgroup auto46CB7266_g;
int auto46CB7266_u;
// Variable Initialization
// Conditions
if (testConds) {
if (!((libGame_gf_HeroGainTalentGainedTalent() == "SamuroHeroicAbilityIllusionMaster"))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
lv_samuroPlayer = libGame_gf_HeroGainTalentPlayer();
lv_samuro = libGame_gv_players[lv_samuroPlayer].lv_heroUnit;
if ((PlayerHasTalent(lv_samuroPlayer, "SamuroHeroicAbilityIllusionMaster") == true)) {
UnitGroupAdd(libHSAM_gv_mirrorImageUnitGroup2[lv_samuroPlayer], UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup[lv_samuroPlayer], 1));
UnitGroupAdd(libHSAM_gv_mirrorImageUnitGroup3[lv_samuroPlayer], UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup[lv_samuroPlayer], 2));
UnitBehaviorAdd(UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup[lv_samuroPlayer], 1), "SamuroMirrorImage1Dummy", lv_samuro, 1);
UnitBehaviorAdd(UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup[lv_samuroPlayer], 2), "SamuroMirrorImage2Dummy", lv_samuro, 1);
if ((libGame_gv_players[lv_samuroPlayer].lv_activeVehicle == null)) {
UnitControlGroupAddUnit(libGame_gf_HeroGainTalentPlayer(), 1, libGame_gv_players[lv_samuroPlayer].lv_heroUnit);
UnitControlGroupAddUnit(libGame_gf_HeroGainTalentPlayer(), 4, libGame_gv_players[lv_samuroPlayer].lv_heroUnit);
}
else {
UnitControlGroupAddUnit(libGame_gf_HeroGainTalentPlayer(), 1, libGame_gv_players[lv_samuroPlayer].lv_activeVehicle);
UnitControlGroupAddUnit(libGame_gf_HeroGainTalentPlayer(), 4, libGame_gv_players[lv_samuroPlayer].lv_activeVehicle);
}
UnitControlGroupAddUnit(lv_samuroPlayer, 4, UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup[lv_samuroPlayer], 1));
UnitControlGroupAddUnit(lv_samuroPlayer, 4, UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup[lv_samuroPlayer], 2));
UnitControlGroupAddUnit(lv_samuroPlayer, 3, UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup[lv_samuroPlayer], 2));
libNtve_gf_SendActorMessageToUnit(UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup[lv_samuroPlayer], 2), "SetUnitIcon Assets\\Textures\\storm_ui_icon_samuro_selectmirror2.dds");
UnitControlGroupAddUnit(lv_samuroPlayer, 2, UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup[lv_samuroPlayer], 1));
UnitBehaviorAdd(UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup[lv_samuroPlayer], 1), "Ultimate2Unlocked", libGame_gv_players[lv_samuroPlayer].lv_heroUnit, UnitBehaviorCount(lv_samuro, "Ultimate2Unlocked"));
UnitBehaviorAdd(UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup[lv_samuroPlayer], 2), "Ultimate2Unlocked", libGame_gv_players[lv_samuroPlayer].lv_heroUnit, UnitBehaviorCount(lv_samuro, "Ultimate2Unlocked"));
UISetSelectionTypeEnabled(PlayerGroupSingle(lv_samuroPlayer), c_localSelectionTypeUnknown, true);
UISetDragSelectEnabled(PlayerGroupSingle(lv_samuroPlayer), true);
UISetFrameVisible(PlayerGroupSingle(lv_samuroPlayer), c_syncFrameTypeControlGroupPanel, true);
UnitBehaviorAdd(lv_samuro, "SamuroIllusionMasterToggleAIBehaviorAbil", lv_samuro, 1);
auto46CB7266_g = libHSAM_gv_mirrorImageUnitGroup[lv_samuroPlayer];
auto46CB7266_u = UnitGroupCount(auto46CB7266_g, c_unitCountAll);
for (;; auto46CB7266_u -= 1) {
lv_samuro2 = UnitGroupUnitFromEnd(auto46CB7266_g, auto46CB7266_u);
if (lv_samuro2 == null) { break; }
UnitBehaviorAdd(lv_samuro2, "SamuroIllusionMasterToggleAIBehaviorAbil", lv_samuro2, 1);
}
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHSAM_gt_SamuroGainsR2Talent_Init () {
libHSAM_gt_SamuroGainsR2Talent = TriggerCreate("libHSAM_gt_SamuroGainsR2Talent_Func");
TriggerEnable(libHSAM_gt_SamuroGainsR2Talent, false);
libGame_gf_HeroGainTalent(libHSAM_gt_SamuroGainsR2Talent);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Samuro - Control Group Panel Initialize
//--------------------------------------------------------------------------------------------------
bool libHSAM_gt_SamuroControlGroupPanelInitialize_Func (bool testConds, bool runActions) {
// Automatic Variable Declarations
// Actions
if (!runActions) {
return true;
}
DialogControlHookupStandard(c_triggerControlTypePanel, "UIContainer/ConsoleUIContainer/ControlGroupPanel");
libUIUI_gf_UISetDialogItemToSelectedOrObserved(DialogControlLastCreated());
libHSAM_gv_samuro_ControlGroupPanel = DialogControlLastCreated();
return true;
}
//--------------------------------------------------------------------------------------------------
void libHSAM_gt_SamuroControlGroupPanelInitialize_Init () {
libHSAM_gt_SamuroControlGroupPanelInitialize = TriggerCreate("libHSAM_gt_SamuroControlGroupPanelInitialize_Func");
libCore_gf_IncludeModInitialization(libHSAM_gt_SamuroControlGroupPanelInitialize);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Samuro - UI Clean Up UI For Debug Hero Swap
//--------------------------------------------------------------------------------------------------
bool libHSAM_gt_SamuroUICleanUpUIForDebugHeroSwap_Func (bool testConds, bool runActions) {
// Variable Declarations
int lv_player;
// Automatic Variable Declarations
// Variable Initialization
// Actions
if (!runActions) {
return true;
}
lv_player = libGame_gf_DebugHeroSwappedPlayer();
if ((libGame_gv_players[lv_player].lv_heroIndex != libCore_gf_GetHeroIndexForUnitType("HeroSamuro"))) {
libHSAM_gf_SamuroUIUnSetupUIForPlayer(lv_player);
}
else {
TriggerExecute(libHSAM_gt_SamuroUIInitialize, true, false);
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHSAM_gt_SamuroUICleanUpUIForDebugHeroSwap_Init () {
libHSAM_gt_SamuroUICleanUpUIForDebugHeroSwap = TriggerCreate("libHSAM_gt_SamuroUICleanUpUIForDebugHeroSwap_Func");
libGame_gf_DebugHeroSwapped(libHSAM_gt_SamuroUICleanUpUIForDebugHeroSwap);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Samuro - UI Initialize
//--------------------------------------------------------------------------------------------------
bool libHSAM_gt_SamuroUIInitialize_Func (bool testConds, bool runActions) {
int init_i;
// Variable Declarations
int[6] lv_panels;
int lv_currentPanelLayer;
// Automatic Variable Declarations
// Variable Initialization
for (init_i = 0; init_i <= 5; init_i += 1) {
lv_panels[init_i] = c_invalidDialogControlId;
}
// Actions
if (!runActions) {
return true;
}
DialogControlHookup(libHSAM_gv_samuro_ControlGroupPanel, c_triggerControlTypeImage, "ControlGroupButton0/SamuroMirror0IconSelected");
libHSAM_gv_samuroUI.lv_samuroControlGroupIcon0 = DialogControlLastCreated();
DialogControlHookup(libHSAM_gv_samuro_ControlGroupPanel, c_triggerControlTypeImage, "ControlGroupButton1/SamuroMirror1IconSelected");
libHSAM_gv_samuroUI.lv_samuroControlGroupIcon1 = DialogControlLastCreated();
DialogControlHookup(libHSAM_gv_samuro_ControlGroupPanel, c_triggerControlTypeImage, "ControlGroupButton2/SamuroMirror2IconSelected");
libHSAM_gv_samuroUI.lv_samuroControlGroupIcon2 = DialogControlLastCreated();
DialogControlHookup(libHSAM_gv_samuro_ControlGroupPanel, c_triggerControlTypeImage, "ControlGroupButton3/SamuroMirror3IconSelected");
libHSAM_gv_samuroUI.lv_samuroControlGroupIcon3 = DialogControlLastCreated();
DialogControlHookup(libHSAM_gv_samuro_ControlGroupPanel, c_triggerControlTypeProgressBar, "ControlGroupButton1/ProgressBarHealth1");
libHSAM_gv_samuroUI.lv_samuroControlGroupIconHealth1 = DialogControlLastCreated();
DialogControlHookup(libHSAM_gv_samuro_ControlGroupPanel, c_triggerControlTypeProgressBar, "ControlGroupButton2/ProgressBarHealth2");
libHSAM_gv_samuroUI.lv_samuroControlGroupIconHealth2 = DialogControlLastCreated();
lv_currentPanelLayer += 1;
lv_panels[lv_currentPanelLayer] = DialogControlLastCreated();
return true;
}
//--------------------------------------------------------------------------------------------------
void libHSAM_gt_SamuroUIInitialize_Init () {
libHSAM_gt_SamuroUIInitialize = TriggerCreate("libHSAM_gt_SamuroUIInitialize_Func");
libCore_gf_IncludeModInitialization(libHSAM_gt_SamuroUIInitialize);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Samuro - Control Group Highlight Selection Controller
//--------------------------------------------------------------------------------------------------
bool libHSAM_gt_SamuroControlGroupHighlightSelectionController_Func (bool testConds, bool runActions) {
// Variable Declarations
int lv_itSamuroPlayer;
// Automatic Variable Declarations
int auto5798CD88_ae;
// Variable Initialization
// Conditions
if (testConds) {
if (!(((UnitGetType(EventUnit()) == "HeroSamuro") || (UnitGetType(EventUnit()) == "SamuroMirrorImage")))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
auto5798CD88_ae = libCore_gv_bALMaxPlayers;
lv_itSamuroPlayer = 1;
for ( ; lv_itSamuroPlayer <= auto5798CD88_ae ; lv_itSamuroPlayer += 1 ) {
if ((UnitIsSelected(UnitGroupUnit(libGame_gv_players[lv_itSamuroPlayer].lv_heroUnitGroup, 1), lv_itSamuroPlayer) == true) && (UnitIsSelected(UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup2[lv_itSamuroPlayer], 1), lv_itSamuroPlayer) == false) && (UnitIsSelected(UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup3[lv_itSamuroPlayer], 1), lv_itSamuroPlayer) == false)) {
DialogControlSetVisible(libHSAM_gv_samuroUI.lv_samuroControlGroupIcon0, libCore_gv_playerGroupFromPlayer[lv_itSamuroPlayer], true);
DialogControlSetVisible(libHSAM_gv_samuroUI.lv_samuroControlGroupIcon1, libCore_gv_playerGroupFromPlayer[lv_itSamuroPlayer], false);
DialogControlSetVisible(libHSAM_gv_samuroUI.lv_samuroControlGroupIcon2, libCore_gv_playerGroupFromPlayer[lv_itSamuroPlayer], false);
DialogControlSetVisible(libHSAM_gv_samuroUI.lv_samuroControlGroupIcon3, libCore_gv_playerGroupFromPlayer[lv_itSamuroPlayer], false);
libNtve_gf_SendActorMessageToUnit(UnitGroupUnit(libGame_gv_players[lv_itSamuroPlayer].lv_heroUnitGroup, 1), "Signal SamuroSelectionCreateClick");
}
if ((UnitIsSelected(UnitGroupUnit(libGame_gv_players[lv_itSamuroPlayer].lv_heroUnitGroup, 1), lv_itSamuroPlayer) == false) && (UnitIsSelected(UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup2[lv_itSamuroPlayer], 1), lv_itSamuroPlayer) == true) && (UnitIsSelected(UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup3[lv_itSamuroPlayer], 1), lv_itSamuroPlayer) == false)) {
DialogControlSetVisible(libHSAM_gv_samuroUI.lv_samuroControlGroupIcon0, libCore_gv_playerGroupFromPlayer[lv_itSamuroPlayer], false);
DialogControlSetVisible(libHSAM_gv_samuroUI.lv_samuroControlGroupIcon1, libCore_gv_playerGroupFromPlayer[lv_itSamuroPlayer], true);
DialogControlSetVisible(libHSAM_gv_samuroUI.lv_samuroControlGroupIcon2, libCore_gv_playerGroupFromPlayer[lv_itSamuroPlayer], false);
DialogControlSetVisible(libHSAM_gv_samuroUI.lv_samuroControlGroupIcon3, libCore_gv_playerGroupFromPlayer[lv_itSamuroPlayer], false);
libNtve_gf_SendActorMessageToUnit(UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup2[lv_itSamuroPlayer], 1), "Signal SamuroSelectionCreateClick");
}
if ((UnitIsSelected(UnitGroupUnit(libGame_gv_players[lv_itSamuroPlayer].lv_heroUnitGroup, 1), lv_itSamuroPlayer) == false) && (UnitIsSelected(UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup2[lv_itSamuroPlayer], 1), lv_itSamuroPlayer) == false) && (UnitIsSelected(UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup3[lv_itSamuroPlayer], 1), lv_itSamuroPlayer) == true)) {
DialogControlSetVisible(libHSAM_gv_samuroUI.lv_samuroControlGroupIcon0, libCore_gv_playerGroupFromPlayer[lv_itSamuroPlayer], false);
DialogControlSetVisible(libHSAM_gv_samuroUI.lv_samuroControlGroupIcon1, libCore_gv_playerGroupFromPlayer[lv_itSamuroPlayer], false);
DialogControlSetVisible(libHSAM_gv_samuroUI.lv_samuroControlGroupIcon2, libCore_gv_playerGroupFromPlayer[lv_itSamuroPlayer], true);
DialogControlSetVisible(libHSAM_gv_samuroUI.lv_samuroControlGroupIcon3, libCore_gv_playerGroupFromPlayer[lv_itSamuroPlayer], false);
libNtve_gf_SendActorMessageToUnit(UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup3[lv_itSamuroPlayer], 1), "Signal SamuroSelectionCreateClick");
}
if ((UnitIsSelected(UnitGroupUnit(libGame_gv_players[lv_itSamuroPlayer].lv_heroUnitGroup, 1), lv_itSamuroPlayer) == true) && (UnitIsSelected(UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup2[lv_itSamuroPlayer], 1), lv_itSamuroPlayer) == true) && (UnitIsSelected(UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup3[lv_itSamuroPlayer], 1), lv_itSamuroPlayer) == true)) {
DialogControlSetVisible(libHSAM_gv_samuroUI.lv_samuroControlGroupIcon0, libCore_gv_playerGroupFromPlayer[lv_itSamuroPlayer], false);
DialogControlSetVisible(libHSAM_gv_samuroUI.lv_samuroControlGroupIcon1, libCore_gv_playerGroupFromPlayer[lv_itSamuroPlayer], false);
DialogControlSetVisible(libHSAM_gv_samuroUI.lv_samuroControlGroupIcon2, libCore_gv_playerGroupFromPlayer[lv_itSamuroPlayer], false);
DialogControlSetVisible(libHSAM_gv_samuroUI.lv_samuroControlGroupIcon3, libCore_gv_playerGroupFromPlayer[lv_itSamuroPlayer], true);
libNtve_gf_SendActorMessageToUnit(UnitGroupUnit(libGame_gv_players[lv_itSamuroPlayer].lv_heroUnitGroup, 1), "Signal SamuroSelectionCreateClick");
}
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHSAM_gt_SamuroControlGroupHighlightSelectionController_Init () {
libHSAM_gt_SamuroControlGroupHighlightSelectionController = TriggerCreate("libHSAM_gt_SamuroControlGroupHighlightSelectionController_Func");
TriggerEnable(libHSAM_gt_SamuroControlGroupHighlightSelectionController, false);
TriggerAddEventUnitSelected(libHSAM_gt_SamuroControlGroupHighlightSelectionController, null, c_playerAny, true);
TriggerAddEventUnitSelected(libHSAM_gt_SamuroControlGroupHighlightSelectionController, null, c_playerAny, false);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Samuro - Mirror Image Health Tracker Create
//--------------------------------------------------------------------------------------------------
bool libHSAM_gt_SamuroMirrorImageHealthTrackerCreate_Func (bool testConds, bool runActions) {
// Automatic Variable Declarations
// Conditions
if (testConds) {
if (!((UnitGetType(EventUnitCreatedUnit()) == "SamuroMirrorImage"))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
Wait(0.188, c_timeGame);
if ((EventUnitCreatedUnit() == UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup2[UnitGetOwner(EventUnit())], 1)) && (UnitGetPropertyFixed(libGame_gv_players[UnitGetOwner(EventUnit())].lv_heroUnit, c_unitPropLife, c_unitPropCurrent) == UnitGetPropertyFixed(libGame_gv_players[UnitGetOwner(EventUnit())].lv_heroUnit, c_unitPropLifeMax, c_unitPropCurrent))) {
libNtve_gf_SetDialogItemCurrentValue(libHSAM_gv_samuroUI.lv_samuroControlGroupIconHealth1, 100.0, libCore_gv_playerGroupFromPlayer[UnitGetOwner(EventUnit())]);
}
if ((EventUnitCreatedUnit() == UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup3[UnitGetOwner(EventUnit())], 1)) && (UnitGetPropertyFixed(libGame_gv_players[UnitGetOwner(EventUnit())].lv_heroUnit, c_unitPropLife, c_unitPropCurrent) == UnitGetPropertyFixed(libGame_gv_players[UnitGetOwner(EventUnit())].lv_heroUnit, c_unitPropLifeMax, c_unitPropCurrent))) {
libNtve_gf_SetDialogItemCurrentValue(libHSAM_gv_samuroUI.lv_samuroControlGroupIconHealth2, 100.0, libCore_gv_playerGroupFromPlayer[UnitGetOwner(EventUnit())]);
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHSAM_gt_SamuroMirrorImageHealthTrackerCreate_Init () {
libHSAM_gt_SamuroMirrorImageHealthTrackerCreate = TriggerCreate("libHSAM_gt_SamuroMirrorImageHealthTrackerCreate_Func");
TriggerEnable(libHSAM_gt_SamuroMirrorImageHealthTrackerCreate, false);
TriggerAddEventUnitCreated(libHSAM_gt_SamuroMirrorImageHealthTrackerCreate, null, null, null);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Samuro - Mirror Image Health Tracker Create Talent Taken
//--------------------------------------------------------------------------------------------------
bool libHSAM_gt_SamuroMirrorImageHealthTrackerCreateTalentTaken_Func (bool testConds, bool runActions) {
// Variable Declarations
int lv_itSamuroPlayer;
// Automatic Variable Declarations
int auto3D8F6E9A_ae;
// Variable Initialization
// Conditions
if (testConds) {
if (!((libGame_gf_HeroGainTalentGainedTalent() == "SamuroHeroicAbilityIllusionMaster"))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
lv_itSamuroPlayer = libGame_gf_HeroGainTalentPlayer();
Wait(0.188, c_timeGame);
auto3D8F6E9A_ae = libCore_gv_bALMaxPlayers;
lv_itSamuroPlayer = 1;
for ( ; lv_itSamuroPlayer <= auto3D8F6E9A_ae ; lv_itSamuroPlayer += 1 ) {
DialogControlSetVisible(libHSAM_gv_samuroUI.lv_samuroControlGroupIconHealth1, libCore_gv_playerGroupFromPlayer[lv_itSamuroPlayer], true);
DialogControlSetVisible(libHSAM_gv_samuroUI.lv_samuroControlGroupIconHealth2, libCore_gv_playerGroupFromPlayer[lv_itSamuroPlayer], true);
}
if ((UnitGetPropertyFixed(libGame_gv_players[lv_itSamuroPlayer].lv_heroUnit, c_unitPropLife, c_unitPropCurrent) == UnitGetPropertyFixed(libGame_gv_players[lv_itSamuroPlayer].lv_heroUnit, c_unitPropLifeMax, c_unitPropCurrent))) {
libNtve_gf_SetDialogItemCurrentValue(libHSAM_gv_samuroUI.lv_samuroControlGroupIconHealth1, 100.0, libCore_gv_playerGroupFromPlayer[lv_itSamuroPlayer]);
}
if ((UnitGetPropertyFixed(libGame_gv_players[lv_itSamuroPlayer].lv_heroUnit, c_unitPropLife, c_unitPropCurrent) == UnitGetPropertyFixed(libGame_gv_players[lv_itSamuroPlayer].lv_heroUnit, c_unitPropLifeMax, c_unitPropCurrent))) {
libNtve_gf_SetDialogItemCurrentValue(libHSAM_gv_samuroUI.lv_samuroControlGroupIconHealth2, 100.0, libCore_gv_playerGroupFromPlayer[lv_itSamuroPlayer]);
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHSAM_gt_SamuroMirrorImageHealthTrackerCreateTalentTaken_Init () {
libHSAM_gt_SamuroMirrorImageHealthTrackerCreateTalentTaken = TriggerCreate("libHSAM_gt_SamuroMirrorImageHealthTrackerCreateTalentTaken_Func");
TriggerEnable(libHSAM_gt_SamuroMirrorImageHealthTrackerCreateTalentTaken, false);
libGame_gf_HeroGainTalent(libHSAM_gt_SamuroMirrorImageHealthTrackerCreateTalentTaken);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Samuro - Mirror Image Health Tracker Update
//--------------------------------------------------------------------------------------------------
bool libHSAM_gt_SamuroMirrorImageHealthTrackerUpdate_Func (bool testConds, bool runActions) {
// Variable Declarations
fixed lv_itMirrorImageCurrentHealth;
fixed lv_itMirrorImageMaxHealth;
fixed lv_itSamuroPrimeMaxHealth;
int lv_itSamuroPlayer;
// Automatic Variable Declarations
// Variable Initialization
// Conditions
if (testConds) {
if (!((UnitGetType(EventUnit()) == "SamuroMirrorImage"))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
if ((EventUnit() == UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup2[UnitGetOwner(EventUnit())], 1))) {
lv_itMirrorImageCurrentHealth = UnitGetPropertyFixed(EventUnit(), c_unitPropLife, c_unitPropCurrent);
lv_itMirrorImageMaxHealth = UnitGetPropertyFixed(EventUnit(), c_unitPropLifeMax, c_unitPropCurrent);
libNtve_gf_SetDialogItemCurrentValue(libHSAM_gv_samuroUI.lv_samuroControlGroupIconHealth1, FixedToInt((100.0 * (lv_itMirrorImageCurrentHealth / lv_itMirrorImageMaxHealth))), libCore_gv_playerGroupFromPlayer[UnitGetOwner(EventUnit())]);
}
if ((EventUnit() == UnitGroupUnit(libHSAM_gv_mirrorImageUnitGroup3[UnitGetOwner(EventUnit())], 1))) {
lv_itMirrorImageCurrentHealth = UnitGetPropertyFixed(EventUnit(), c_unitPropLife, c_unitPropCurrent);
lv_itMirrorImageMaxHealth = UnitGetPropertyFixed(EventUnit(), c_unitPropLifeMax, c_unitPropCurrent);
libNtve_gf_SetDialogItemCurrentValue(libHSAM_gv_samuroUI.lv_samuroControlGroupIconHealth2, FixedToInt((100.0 * (lv_itMirrorImageCurrentHealth / lv_itMirrorImageMaxHealth))), libCore_gv_playerGroupFromPlayer[UnitGetOwner(EventUnit())]);
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHSAM_gt_SamuroMirrorImageHealthTrackerUpdate_Init () {
libHSAM_gt_SamuroMirrorImageHealthTrackerUpdate = TriggerCreate("libHSAM_gt_SamuroMirrorImageHealthTrackerUpdate_Func");
TriggerEnable(libHSAM_gt_SamuroMirrorImageHealthTrackerUpdate, false);
TriggerAddEventUnitProperty(libHSAM_gt_SamuroMirrorImageHealthTrackerUpdate, null, c_unitPropLife);
}
void libHSAM_InitTriggers () {
libHSAM_gt_ForceIncludeDataMods_Init();
libHSAM_gt_SamuroSelectionChange_Init();
libHSAM_gt_SamuroRespawn_Init();
libHSAM_gt_SamuroPort_Init();
libHSAM_gt_SamuroDebugSwap_Init();
libHSAM_gt_SamuroRespecsTalents_Init();
libHSAM_gt_SamuroSamuroDies_Init();
libHSAM_gt_SamuroUsesTransport_Init();
libHSAM_gt_SamuroGainsMapMechanicStack_Init();
libHSAM_gt_SamuroMirrorImageSelectedOn_Init();
libHSAM_gt_SamuroMirrorImageSelectedOff_Init();
libHSAM_gt_SamuroMirrorImageSwap_Init();
libHSAM_gt_SamuroMirrorImageMountDismountPort_Init();
libHSAM_gt_SamuroMirrorImageCreated_Init();
libHSAM_gt_SamuroMirrorImageDies_Init();
libHSAM_gt_SamuroMirrorImageController_Init();
libHSAM_gt_SamuroMirrorImageIllusionMasterAIToggleOn_Init();
libHSAM_gt_SamuroMirrorImageIllusionMasterAIToggleOff_Init();
libHSAM_gt_SamuroMirrorImageAttackOrderRedirectAI_Init();
libHSAM_gt_SamuroMirrorImageDamageTakenDuplication_Init();
libHSAM_gt_SamuroCriticalStrike_Init();
libHSAM_gt_SamuroBladestorm_Init();
libHSAM_gt_SamuroWayofIllusion_Init();
libHSAM_gt_SamuroGainsWayofIllusion_Init();
libHSAM_gt_SamuroLosesWayofIllusion_Init();
libHSAM_gt_SamuroGainsThreeBladeStyleTalent_Init();
libHSAM_gt_SamuroGainsCrushingBlowTalent_Init();
libHSAM_gt_SamuroMirage_Init();
libHSAM_gt_SamuroGainsR2Talent_Init();
libHSAM_gt_SamuroControlGroupPanelInitialize_Init();
libHSAM_gt_SamuroUICleanUpUIForDebugHeroSwap_Init();
libHSAM_gt_SamuroUIInitialize_Init();
libHSAM_gt_SamuroControlGroupHighlightSelectionController_Init();
libHSAM_gt_SamuroMirrorImageHealthTrackerCreate_Init();
libHSAM_gt_SamuroMirrorImageHealthTrackerCreateTalentTaken_Init();
libHSAM_gt_SamuroMirrorImageHealthTrackerUpdate_Init();
}
//--------------------------------------------------------------------------------------------------
// Library Initialization
//--------------------------------------------------------------------------------------------------
bool libHSAM_InitLib_completed = false;
void libHSAM_InitLib () {
if (libHSAM_InitLib_completed) {
return;
}
libHSAM_InitLib_completed = true;
libHSAM_InitLibraries();
libHSAM_InitVariables();
libHSAM_InitTriggers();
}