PTR build 2.57.1.98674_ptr. Go to the live site.

mods/heromods/samuro.stormmod/base.stormdata/libhsam.galaxy

libhsam.galaxy
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 - 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_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();
}