include "TriggerLibs/NativeLib"

include "TriggerLibs/HeroesLib"

include "TriggerLibs/GameLib"

include "TriggerLibs/MapMechanicsLib"

include "TriggerLibs/AILib"

include "TriggerLibs/UILib"

include "TriggerLibs/SoundLib"

include "LibOVER"

include "LibNPLD_h"



include "LibMHmu_h"



//--------------------------------------------------------------------------------------------------

// Library: Hanamura

//--------------------------------------------------------------------------------------------------

// External Library Initialization

void libMHmu_InitLibraries () {

    libNtve_InitVariables();

    libCore_InitVariables();

    libGame_InitVariables();

    libMapM_InitVariables();

    libAIAI_InitVariables();

    libUIUI_InitVariables();

    libSond_InitVariables();

    libOVER_InitVariables();

    libNPLD_InitVariables();

}



// Variable Initialization

bool libMHmu_InitVariables_completed = false;



void libMHmu_InitVariables () {

    int init_i;



    if (libMHmu_InitVariables_completed) {

        return;

    }



    libMHmu_InitVariables_completed = true;



    libMHmu_gv_mapMechanic_WarningTimer_Duration = 30;

    libMHmu_gv_hanamura.lv_mapMechanic_ObjectivePreviewTimer = TimerCreate();

    libMHmu_gv_hanamura.lv_mapMechanic_ObjectivePreviewDelay = TimerCreate();

    libMHmu_gv_hanamuraMM10secondcountdownTimer = TimerCreate();

    libMHmu_gv_hanamuraUseVisionCamps = true;

    libMHmu_gv_elevator_Forced_Lower_Timer = TimerCreate();

    libMHmu_gv_elevator.lv_elevatorInitialRaiseTimer = TimerCreate();

    libMHmu_gv_elevator.lv_elevatorRaiseTimer = TimerCreate();

    libMHmu_gv_elevator.lv_elevatorLowerTimer = TimerCreate();

    libMHmu_gv_elevator.lv_elevatorWasLowered = true;

    libMHmu_gv_elevator.lv_elevatorLowerTime = 5.5;

    for (init_i = 0; init_i <= libCore_gv_bALMaxPlayers; init_i += 1) {

        libMHmu_gv_eOMPusherTimer[init_i] = TimerCreate();

    }

}



// Functions

void libMHmu_gf_InitSwordsmanMercCampBruiserCamp1 () {

    // Variable Declarations

    int lv_campType;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_campType = (libMapM_ge_JungleCampMercTypes_BruiserCamp1);



    // Implementation

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_campTypeMinimapTitleLabel = StringExternal("Param/Value/lib_MHmu_266EF322");

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_campTypeMinimapLabel = StringExternal("Param/Value/lib_MHmu_C76BE77C");

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_campIsElite = true;

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_aIGoalLink = "MercenaryCampSentinel";

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_customTextTagInfoText = StringExternal("Param/Value/lib_MHmu_8EDE85AD");

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_customTextTagTitle = StringExternal("Param/Value/lib_MHmu_A37682C3");

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_campIsSoloable = true;

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_initialSpawnDelay = 30.0;

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_respawnTime = 150.0;

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_numberOfCreeps = 1;

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_creepUnitTypes[1] = "MercDefenderSentinel";

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_defendersCoweronDeath = true;

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_defenderCoweringUnit[1] = true;

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_xPAwardForCapture = libMHmu_gv_swordsmanCampXPValue;

    libMapM_gv_dataJungleCampMercData[lv_campType].lv_numberOfMinionsSpawned = 1;

    libMapM_gv_dataJungleCampMercData[lv_campType].lv_spawnedMinionUnitTypes[1] = "MercLanerSentinel";

    libMapM_gf_DataInitializeScalingDataForDefender(libMapM_ge_JungleCampDefenderTypes_BruiserCamp1, ("MercenaryDefenderSwordsmanScaling"));

    libMapM_gf_DataInitializeScalingDataForMerc(libMapM_ge_JungleCampMercTypes_BruiserCamp1, "MercenaryLanerSwordsmanScaling");

    libUIUI_gf_PingCreateNewPingTarget("MercDefenderSentinel", false, StringExternal("Param/Value/lib_MHmu_0A42BC84"), StringExternal("Param/Value/lib_MHmu_F6154CDF"), StringExternal("Param/Value/lib_MHmu_BBDCD033"), SoundLink("UI_Game_Ping_Attack", -1), SoundLink("UI_Game_Ping_Attack", -1));

    libUIUI_gf_PingSetHumanAISourceHeroVOForPingTarget(libUIUI_gf_PingLastCreatedPingTarget(), libCore_ge_HeroVOEvents_PingAttackMercCamp, libCore_ge_HeroVOEvents_AIMercCapture);

    libUIUI_gf_PingCreateNewPingTarget("MercLanerSentinel", false, StringExternal("Param/Value/lib_MHmu_E6866234"), StringExternal("Param/Value/lib_MHmu_0A114711"), StringExternal("Param/Value/lib_MHmu_6CC3159A"), SoundLink("UI_Game_Ping_Attack", -1), SoundLink("UI_Game_Ping_Attack", -1));

    libUIUI_gf_PingSetAllyEnemyTargetHeroVOForPingTarget(libUIUI_gf_PingLastCreatedPingTarget(), libCore_ge_HeroVOEvents_PingAttackHere, libCore_ge_HeroVOEvents_PingAttackHere);

}



void libMHmu_gf_InitVisionMercCampBruiserCamp3 () {

    // Variable Declarations

    int lv_campType;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_campType = (libMapM_ge_JungleCampMercTypes_BruiserCamp3);



    // Implementation

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_campTypeMinimapLabel = StringExternal("Param/Value/lib_MHmu_ADACEBB9");

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_aIGoalLink = "MercenaryCampVision";

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_campTypeMinimapTitleLabel = StringExternal("Param/Value/lib_MHmu_C6DE081A");

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_customTextTagTitle = StringExternal("Param/Value/lib_MHmu_87CF46DA");

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_customTextTagInfoText = StringExternal("Param/Value/lib_MHmu_DC6304E1");

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_campIsSoloable = true;

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_initialSpawnDelay = libMapM_gv_reconCampInitialSpawnDelay_C;

    libMHmu_gv_henchmenBirthStunDelay = CatalogFieldValueGetAsFixed(c_gameCatalogBehavior, "MercenaryHenchmen_BirthStun", "Duration", c_playerAny);

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_respawnTime = -1.0;

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_numberOfCreeps = 3;

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_defendersCoweronDeath = true;

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_defenderCoweringUnit[1] = true;

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_defenderCoweringUnit[2] = true;

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_defenderCoweringUnit[3] = true;

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_xPAwardForCapture = libMHmu_gv_visionCampXPValue;

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_creepUnitTypes[1] = "MercDefenderHenchman1";

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_creepUnitTypes[2] = "MercDefenderHenchman2";

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_creepUnitTypes[3] = "MercDefenderHenchman3";

    libMapM_gv_dataJungleCampMercData[lv_campType].lv_numberOfMinionsSpawned = 0;

    libMapM_gf_DataInitializeScalingDataForDefender(libMapM_ge_JungleCampDefenderTypes_BruiserCamp3, "MercHenchmanDefender");

    libMapM_gf_DataInitializeScalingDataForMerc(libMapM_ge_JungleCampMercTypes_BruiserCamp3, "MercHenchmanLaner");

    libUIUI_gf_PingCreateNewPingTarget("MercDefenderHenchman1", false, StringExternal("Param/Value/lib_MHmu_61A51BCC"), StringExternal("Param/Value/lib_MHmu_E69F3AB6"), StringExternal("Param/Value/lib_MHmu_74EE44C1"), SoundLink("UI_Game_Ping_Attack", -1), SoundLink("UI_Game_Ping_Attack", -1));

    libUIUI_gf_PingSetHumanAISourceHeroVOForPingTarget(libUIUI_gf_PingLastCreatedPingTarget(), libCore_ge_HeroVOEvents_PingAttackMercCamp, libCore_ge_HeroVOEvents_AIMercCapture);

    libUIUI_gf_PingCreateNewPingTarget("MercDefenderHenchman2", false, StringExternal("Param/Value/lib_MHmu_F6EDE711"), StringExternal("Param/Value/lib_MHmu_897F193F"), StringExternal("Param/Value/lib_MHmu_2A477589"), SoundLink("UI_Game_Ping_Attack", -1), SoundLink("UI_Game_Ping_Attack", -1));

    libUIUI_gf_PingSetHumanAISourceHeroVOForPingTarget(libUIUI_gf_PingLastCreatedPingTarget(), libCore_ge_HeroVOEvents_PingAttackMercCamp, libCore_ge_HeroVOEvents_AIMercCapture);

    libUIUI_gf_PingCreateNewPingTarget("MercDefenderHenchman3", false, StringExternal("Param/Value/lib_MHmu_93712FFE"), StringExternal("Param/Value/lib_MHmu_E07E2CC6"), StringExternal("Param/Value/lib_MHmu_8FDD0F62"), SoundLink("UI_Game_Ping_Attack", -1), SoundLink("UI_Game_Ping_Attack", -1));

    libUIUI_gf_PingSetHumanAISourceHeroVOForPingTarget(libUIUI_gf_PingLastCreatedPingTarget(), libCore_ge_HeroVOEvents_PingAttackMercCamp, libCore_ge_HeroVOEvents_AIMercCapture);

}



void libMHmu_gf_InitKnightsMercCampBruiserCamp3 () {

    // Variable Declarations

    int lv_campType;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_campType = (libMapM_ge_JungleCampMercTypes_BruiserCamp3);



    // Implementation

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_campTypeMinimapLabel = StringExternal("Param/Value/lib_MHmu_1A837C9C");

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_aIGoalLink = "MercenaryCampKnights";

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_campTypeMinimapTitleLabel = StringExternal("Param/Value/lib_MHmu_F68E7F4E");

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_customTextTagTitle = StringExternal("Param/Value/lib_MHmu_E7D49F9A");

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_customTextTagInfoText = StringExternal("Param/Value/lib_MHmu_F3301DFD");

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_campIsSoloable = false;

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_initialSpawnDelay = 60.0;

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_respawnTime = 120.0;

    libOVER_gv_data_XP_IndividualCampCapture = 0.0;

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_numberOfCreeps = 4;

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_xPAwardForCapture = 0.0;

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_creepUnitTypes[1] = "MercDefenderRangedMage";

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_creepUnitTypes[2] = "MercDefenderMeleeKnight";

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_creepUnitTypes[3] = "MercDefenderMeleeKnight";

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_creepUnitTypes[4] = "MercDefenderMeleeKnight";

    libMapM_gv_dataJungleCampMercData[lv_campType].lv_numberOfMinionsSpawned = 4;

    libMapM_gv_dataJungleCampMercData[lv_campType].lv_spawnedMinionUnitTypes[1] = "MercLanerRangedMage";

    libMapM_gv_dataJungleCampMercData[lv_campType].lv_spawnedMinionUnitTypes[2] = "MercLanerMeleeKnight";

    libMapM_gv_dataJungleCampMercData[lv_campType].lv_spawnedMinionUnitTypes[3] = "MercLanerMeleeKnight";

    libMapM_gv_dataJungleCampMercData[lv_campType].lv_spawnedMinionUnitTypes[4] = "MercLanerMeleeKnight";

    libMapM_gf_DataInitializeScalingDataForDefender(libMapM_ge_JungleCampDefenderTypes_BruiserCamp3, "KnightMageScaling2");

    libMapM_gf_DataInitializeScalingDataForMerc(libMapM_ge_JungleCampMercTypes_BruiserCamp3, "KnightMageScaling");

    libUIUI_gf_PingCreateNewPingTarget("MercDefenderHenchman1", false, StringExternal("Param/Value/lib_MHmu_D42582E7"), StringExternal("Param/Value/lib_MHmu_D47244CA"), StringExternal("Param/Value/lib_MHmu_C2332EF7"), SoundLink("UI_Game_Ping_Attack", -1), SoundLink("UI_Game_Ping_Attack", -1));

    libUIUI_gf_PingSetHumanAISourceHeroVOForPingTarget(libUIUI_gf_PingLastCreatedPingTarget(), libCore_ge_HeroVOEvents_PingAttackMercCamp, libCore_ge_HeroVOEvents_AIMercCapture);

    libUIUI_gf_PingCreateNewPingTarget("MercDefenderHenchman2", false, StringExternal("Param/Value/lib_MHmu_E7918933"), StringExternal("Param/Value/lib_MHmu_F4F04B02"), StringExternal("Param/Value/lib_MHmu_6F4F5ECE"), SoundLink("UI_Game_Ping_Attack", -1), SoundLink("UI_Game_Ping_Attack", -1));

    libUIUI_gf_PingSetHumanAISourceHeroVOForPingTarget(libUIUI_gf_PingLastCreatedPingTarget(), libCore_ge_HeroVOEvents_PingAttackMercCamp, libCore_ge_HeroVOEvents_AIMercCapture);

    libUIUI_gf_PingCreateNewPingTarget("MercDefenderHenchman3", false, StringExternal("Param/Value/lib_MHmu_C2E1DC99"), StringExternal("Param/Value/lib_MHmu_3382C9DE"), StringExternal("Param/Value/lib_MHmu_4F050A13"), SoundLink("UI_Game_Ping_Attack", -1), SoundLink("UI_Game_Ping_Attack", -1));

    libUIUI_gf_PingSetHumanAISourceHeroVOForPingTarget(libUIUI_gf_PingLastCreatedPingTarget(), libCore_ge_HeroVOEvents_PingAttackMercCamp, libCore_ge_HeroVOEvents_AIMercCapture);

    TriggerEnable(libMHmu_gt_HenchmenCreateVisionUnits, false);

    TriggerEnable(libMHmu_gt_ReconCampTaken, false);

}



void libMHmu_gf_AllDefendersAreStandingonTheirSpawnPoints (int lp_camp) {

    // Variable Declarations

    const fixed lv_allowableDistanceFromPoint_C = 0.4;

    unit lv_defender;

    int lv_defenderNumber;

    bool lv_reset;



    // Automatic Variable Declarations

    unitgroup auto5733E2B1_g;

    int auto5733E2B1_u;



    // Variable Initialization



    // Implementation

    while ((lv_reset == false)) {

        lv_reset = true;

        auto5733E2B1_g = libMapM_gv_jungleCreepCamps[lp_camp].lv_defenderUnitGroup;

        auto5733E2B1_u = UnitGroupCount(auto5733E2B1_g, c_unitCountAll);

        for (;; auto5733E2B1_u -= 1) {

            lv_defender = UnitGroupUnitFromEnd(auto5733E2B1_g, auto5733E2B1_u);

            if (lv_defender == null) { break; }

            lv_defenderNumber = FixedToInt(UnitGetCustomValue(lv_defender, libCore_gf_CustomValueIndex(libCore_ge_CustomValueIndexes_JungleDefenderCreepUnitIndex)));

            if ((DistanceBetweenPoints(UnitGetPosition(lv_defender), libMapM_gv_jungleCreepCamps[lp_camp].lv_mapDataDefenderSpawnPoints[lv_defenderNumber]) > lv_allowableDistanceFromPoint_C)) {

                UnitIssueOrder(lv_defender, OrderTargetingPoint(AbilityCommand("move", 0), libMapM_gv_jungleCreepCamps[lp_camp].lv_mapDataDefenderSpawnPoints[lv_defenderNumber]), c_orderQueueReplace);

                lv_reset = false;

            }

            else {

                libMHmu_gf_OrderDefendertoLookatCenter(lp_camp, lv_defender);

            }

        }

        Wait(0.125, c_timeGame);

    }

}



trigger auto_libMHmu_gf_OrderDefendertoLookatCenter_Trigger = null;

int auto_libMHmu_gf_OrderDefendertoLookatCenter_lp_campID;

unit auto_libMHmu_gf_OrderDefendertoLookatCenter_lp_defender;



void libMHmu_gf_OrderDefendertoLookatCenter (int lp_campID, unit lp_defender) {

    auto_libMHmu_gf_OrderDefendertoLookatCenter_lp_campID = lp_campID;

    auto_libMHmu_gf_OrderDefendertoLookatCenter_lp_defender = lp_defender;



    if (auto_libMHmu_gf_OrderDefendertoLookatCenter_Trigger == null) {

        auto_libMHmu_gf_OrderDefendertoLookatCenter_Trigger = TriggerCreate("auto_libMHmu_gf_OrderDefendertoLookatCenter_TriggerFunc");

    }



    TriggerExecute(auto_libMHmu_gf_OrderDefendertoLookatCenter_Trigger, false, false);

}



bool auto_libMHmu_gf_OrderDefendertoLookatCenter_TriggerFunc (bool testConds, bool runActions) {

    int lp_campID = auto_libMHmu_gf_OrderDefendertoLookatCenter_lp_campID;

    unit lp_defender = auto_libMHmu_gf_OrderDefendertoLookatCenter_lp_defender;



    // Automatic Variable Declarations

    // Implementation

    Wait(0.25, c_timeGame);

    UnitIssueOrder(lp_defender, OrderTargetingPoint(AbilityCommand("move", 4), libMapM_gv_jungleCreepCamps[lp_campID].lv_mapDataCampCaptainSpawnPoint), c_orderQueueReplace);

    return true;

}



trigger auto_libMHmu_gf_HenchmenCustomRespawnCreepsForCamp_Trigger = null;

int auto_libMHmu_gf_HenchmenCustomRespawnCreepsForCamp_lp_camp;

int auto_libMHmu_gf_HenchmenCustomRespawnCreepsForCamp_lp_newOwningPlayer;



void libMHmu_gf_HenchmenCustomRespawnCreepsForCamp (int lp_camp, int lp_newOwningPlayer) {

    auto_libMHmu_gf_HenchmenCustomRespawnCreepsForCamp_lp_camp = lp_camp;

    auto_libMHmu_gf_HenchmenCustomRespawnCreepsForCamp_lp_newOwningPlayer = lp_newOwningPlayer;



    if (auto_libMHmu_gf_HenchmenCustomRespawnCreepsForCamp_Trigger == null) {

        auto_libMHmu_gf_HenchmenCustomRespawnCreepsForCamp_Trigger = TriggerCreate("auto_libMHmu_gf_HenchmenCustomRespawnCreepsForCamp_TriggerFunc");

    }



    TriggerExecute(auto_libMHmu_gf_HenchmenCustomRespawnCreepsForCamp_Trigger, false, false);

}



bool auto_libMHmu_gf_HenchmenCustomRespawnCreepsForCamp_TriggerFunc (bool testConds, bool runActions) {

    int lp_camp = auto_libMHmu_gf_HenchmenCustomRespawnCreepsForCamp_lp_camp;

    int lp_newOwningPlayer = auto_libMHmu_gf_HenchmenCustomRespawnCreepsForCamp_lp_newOwningPlayer;



    // Variable Declarations

    int lv_i;

    fixed lv_StaggeredBirth;

    unit lv_u;

    region lv_aggroRegion;

    string lv_icon;

    int lv_heightOffset;

    text lv_helperTextStart;

    unitgroup lv_defenderGroup;

    unit lv_newUnit;

    int lv_localIndexTracker;



    // Automatic Variable Declarations

    unitgroup auto98AEBFBF_g;

    int auto98AEBFBF_u;

    unitgroup auto2C68DBBA_g;

    int auto2C68DBBA_u;

    unit auto2C68DBBA_var;



    // Variable Initialization

    lv_heightOffset = 4;

    lv_defenderGroup = UnitGroupEmpty();



    // Implementation

    libNtve_gf_SendActorMessageToUnit(libMapM_gv_jungleCreepCamps[lp_camp].lv_campIconUnit, "SetMinimapVisibility 1");

    UnitGroupClear(libMapM_gv_jungleCreepCamps[lp_camp].lv_defenderUnitGroup);

    lv_localIndexTracker = 0;

    auto98AEBFBF_g = libMapM_gv_jungleCreepCamps[lp_camp].lv_defenderCoweringDeadUnitGroup;

    auto98AEBFBF_u = UnitGroupCount(auto98AEBFBF_g, c_unitCountAll);

    for (;; auto98AEBFBF_u -= 1) {

        lv_u = UnitGroupUnitFromEnd(auto98AEBFBF_g, auto98AEBFBF_u);

        if (lv_u == null) { break; }

        lv_localIndexTracker += 1;

        libNtve_gf_SendActorMessageToGameRegion(RegionCircle(UnitGetPosition(lv_u), 1.0), "Signal CreepCleanup");

        UnitCreate(1, libMapM_gv_jungleCreepCamps[lp_camp].lv_defenderUnitTypes[lv_localIndexTracker], c_unitCreateIgnorePlacement, lp_newOwningPlayer, UnitGetPosition(lv_u), UnitGetFacing(lv_u), null);

        lv_newUnit = UnitLastCreated();

        UnitSetCustomValue(lv_newUnit, libCore_gf_CustomValueIndex(libCore_ge_CustomValueIndexes_JungleDefenderCreepUnitIndex), UnitGetCustomValue(lv_u, libCore_gf_CustomValueIndex(libCore_ge_CustomValueIndexes_JungleDefenderCreepUnitIndex)));

        UnitRemove(lv_u);

        UnitGroupAdd(lv_defenderGroup, lv_newUnit);

        UnitGroupAdd(libMapM_gv_jungleCreepCamps[lp_camp].lv_defenderUnitGroup, lv_newUnit);

        UnitSetCustomValue(lv_newUnit, libCore_gf_CustomValueIndex(libCore_ge_CustomValueIndexes_JungleDefenderCreepCampIndex), IntToFixed(lp_camp));

        UnitBehaviorAdd(lv_newUnit, "MercenaryHenchmen_BirthStun", lv_newUnit, 1);

        UnitBehaviorAdd(lv_newUnit, "HenchmentBirthInvulnerability", lv_newUnit, 1);

        UnitBehaviorAdd(lv_newUnit, "JungleCreepPassive", lv_newUnit, 1);

        UnitIssueOrder(lv_newUnit, OrderTargetingPoint(AbilityCommand("move", 0), libMapM_gv_jungleCreepCamps[lp_camp].lv_mapDataDefenderSpawnPoints[FixedToInt(UnitGetCustomValue(lv_newUnit, libCore_gf_CustomValueIndex(libCore_ge_CustomValueIndexes_JungleDefenderCreepUnitIndex)))]), c_orderQueueReplace);

        libGame_gf_SendEventJungleCampDefenderCreated(lv_newUnit);

        if ((libMapM_gv_jungleCreepCamps[lp_camp].lv_defenderCoweringUnit[lv_localIndexTracker] == true)) {

            UnitGroupAdd(libMapM_gv_jungleCreepCamps[lp_camp].lv_defenderCoweringLivingUnitGroup, lv_newUnit);

        }



    }

    libMapM_gv_jungleCreepCamps[lp_camp].lv_defenderDefendersBribedCount = 0;

    libMapM_gv_jungleCreepCamps[lp_camp].lv_stateCurrentDefenderScalingTicks = 0;

    libMapM_gv_jungleCreepCamps[lp_camp].lv_stateCurrentMercScalingTicks = 0;

    libNtve_gf_SendActorMessageToUnit(UnitLastCreated(), (("MinimapIconScale " + FixedToString(libMapM_gv_jungleCreepCamps[lp_camp].lv_mapDataMinimapIconScale, c_fixedPrecisionAny))));

    libMapM_gf_CreateSnapshotOfUnitForBothTeams(libMapM_gv_jungleCreepCamps[lp_camp].lv_campIconUnit);

    libMapM_gf_JungleSwitchToTextTagForCamp(lp_camp);

    libMapM_gf_JungleUpdateMinimapTooltipForCamp(lp_camp);

    libGame_gf_SendEventJungleCampSpawned(lp_camp);

    Wait(libMHmu_gv_henchmenBirthStunDelay, c_timeGame);

    libMHmu_gf_AllDefendersAreStandingonTheirSpawnPoints(lp_camp);

    auto2C68DBBA_g = libMapM_gv_jungleCreepCamps[lp_camp].lv_defenderUnitGroup;

    auto2C68DBBA_u = UnitGroupCount(auto2C68DBBA_g, c_unitCountAll);

    for (;; auto2C68DBBA_u -= 1) {

        auto2C68DBBA_var = UnitGroupUnitFromEnd(auto2C68DBBA_g, auto2C68DBBA_u);

        if (auto2C68DBBA_var == null) { break; }

        UnitBehaviorRemove(auto2C68DBBA_var, "HenchmentBirthInvulnerability", 1);

    }

    libAIAI_gf_StartDefenderAI(false, lv_defenderGroup, libMapM_gv_jungleCreepCamps[lp_camp].lv_mapDataDefenderLeashRegion, lv_aggroRegion, true);

    libMapM_gv_jungleCreepCamps[lp_camp].lv_aIDefenderAIIndex = libAIAI_gf_LastCreatedDefenderAI();

    libGame_gf_JungleUpdateScalingForCamp(lp_camp, libGame_gv_scalingTicks);

    libGame_gf_SendEventJungleCampSpawning(lp_camp);

    UnitSetOwner(libMapM_gv_jungleCreepCamps[lp_camp].lv_campIconUnit, lp_newOwningPlayer, true);

    libMapM_gf_JungleTransitionCampIntoState(lp_camp, libMapM_ge_JungleCampStates_Idle);

    lv_icon = libMapM_gf_JungleGetCurrentIconForJungleCamp(lp_camp, true);

    libNtve_gf_SendActorMessageToUnit(libMapM_gv_jungleCreepCamps[lp_camp].lv_campIconUnit, "MinimapIcon " + lv_icon);

    if ((lp_camp == 5)) {

        AIAddMercenaryCamp(UnitGetPosition(libMapM_gv_jungleCreepCamps[lp_camp].lv_captureCircleOfPowerUnit), lv_defenderGroup, "MercenaryCampVisionTop");

    }

    else {

        AIAddMercenaryCamp(UnitGetPosition(libMapM_gv_jungleCreepCamps[lp_camp].lv_captureCircleOfPowerUnit), lv_defenderGroup, "MercenaryCampVisionBottom");

    }

    return true;

}



trigger auto_libMHmu_gf_HenchmenRuntopointandlookatmiddle_Trigger = null;

unit auto_libMHmu_gf_HenchmenRuntopointandlookatmiddle_lp_henchman;

int auto_libMHmu_gf_HenchmenRuntopointandlookatmiddle_lp_campID;



void libMHmu_gf_HenchmenRuntopointandlookatmiddle (unit lp_henchman, int lp_campID) {

    auto_libMHmu_gf_HenchmenRuntopointandlookatmiddle_lp_henchman = lp_henchman;

    auto_libMHmu_gf_HenchmenRuntopointandlookatmiddle_lp_campID = lp_campID;



    if (auto_libMHmu_gf_HenchmenRuntopointandlookatmiddle_Trigger == null) {

        auto_libMHmu_gf_HenchmenRuntopointandlookatmiddle_Trigger = TriggerCreate("auto_libMHmu_gf_HenchmenRuntopointandlookatmiddle_TriggerFunc");

    }



    TriggerExecute(auto_libMHmu_gf_HenchmenRuntopointandlookatmiddle_Trigger, false, false);

}



bool auto_libMHmu_gf_HenchmenRuntopointandlookatmiddle_TriggerFunc (bool testConds, bool runActions) {

    unit lp_henchman = auto_libMHmu_gf_HenchmenRuntopointandlookatmiddle_lp_henchman;

    int lp_campID = auto_libMHmu_gf_HenchmenRuntopointandlookatmiddle_lp_campID;



    // Variable Declarations

    int lv_indexValue;



    // Automatic Variable Declarations

    // Variable Initialization



    return true;

}



fixed libMHmu_gf_ReturnTownHealth (int lp_town, int lp_owner) {

    // Variable Declarations

    unitgroup lv_group;

    unit lv_itStructure;

    fixed lv_hPTotal;



    // Automatic Variable Declarations

    unitgroup auto91D39D22_g;

    int auto91D39D22_u;



    // Variable Initialization

    lv_group = UnitGroupEmpty();



    // Implementation

    if ((lp_town == 0)) {

        return 0.0;

    }



    lv_group = UnitGroup(null, lp_owner, libGame_gv_townTownData[lp_town].lv_townRegion, UnitFilter((1 << c_targetFilterStructure), (1 << (c_targetFilterAITargetableStructure - 32)), (1 << c_targetFilterNoMinionAggro) | (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32))), 0);

    auto91D39D22_g = lv_group;

    auto91D39D22_u = UnitGroupCount(auto91D39D22_g, c_unitCountAll);

    for (;; auto91D39D22_u -= 1) {

        lv_itStructure = UnitGroupUnitFromEnd(auto91D39D22_g, auto91D39D22_u);

        if (lv_itStructure == null) { break; }

        if ((UnitHasBehavior2(lv_itStructure, "DoesNotGetTargetedByPayload") == false) && ((libGame_gf_TownGetTownStructurePresetFromUnit(lv_itStructure) == libGame_ge_TownStructureTypes_CannonTower) || (libGame_gf_TownGetTownStructurePresetFromUnit(lv_itStructure) == libGame_ge_TownStructureTypes_TownHall) || (libGame_gf_TownGetTownStructurePresetFromUnit(lv_itStructure) == libGame_ge_TownStructureTypes_Gate) || (libGame_gf_TownGetTownStructurePresetFromUnit(lv_itStructure) == libGame_ge_TownStructureTypes_Moonwell))) {

            lv_hPTotal += libCore_gf_GetTotalHPForUnitIncludingAllShields(lv_itStructure);

        }



        if ((UnitHasBehavior2(lv_itStructure, "HanamuraPayloadStructureTarget") == true)) {

            lv_hPTotal -= (StringToFixed(CatalogFieldValueGet(c_gameCatalogEffect, "Payload_AttackDamage", "Amount", 0)) * IntToFixed(UnitBehaviorCount(lv_itStructure, "HanamuraPayloadStructureTarget")));

        }



    }

    return lv_hPTotal;

}



int libMHmu_gf_ReturnHigherHealthTown (int lp_owningTeam, int lp_townIndex_1, int lp_townIndex_2) {

    // Automatic Variable Declarations

    // Implementation

    if ((libMHmu_gf_ReturnTownHealth(lp_townIndex_1, lp_owningTeam) > libMHmu_gf_ReturnTownHealth(lp_townIndex_2, lp_owningTeam)) && (libMHmu_gf_ReturnTownHealth(lp_townIndex_1, lp_owningTeam) > 0.0)) {

        return lp_townIndex_1;

    }

    else {

        if ((libMHmu_gf_ReturnTownHealth(lp_townIndex_2, lp_owningTeam) > libMHmu_gf_ReturnTownHealth(lp_townIndex_1, lp_owningTeam)) && (libMHmu_gf_ReturnTownHealth(lp_townIndex_2, lp_owningTeam) > 0.0)) {

            return lp_townIndex_2;

        }

        else {

            if ((libMHmu_gf_ReturnTownHealth(lp_townIndex_1, lp_owningTeam) > 0.0) && (libMHmu_gf_ReturnTownHealth(lp_townIndex_2, lp_owningTeam) > 0.0) && (libMHmu_gf_ReturnTownHealth(lp_townIndex_1, lp_owningTeam) == libMHmu_gf_ReturnTownHealth(lp_townIndex_2, lp_owningTeam))) {

                if ((RandomInt(0, 1) == 1)) {

                    return lp_townIndex_1;

                }

                else {

                    return lp_townIndex_2;

                }

            }



            return 0;

        }

    }

}



int libMHmu_gf_GetTownForPayloadAttack (int lp_ignoredTownindex, int lp_attackingTeam) {

    // Variable Declarations

    int lv_itTown;

    int[5] lv_index_Town;

    int lv_index_TownToAttack;

    int lv_team_EnemyTeam;

    int lv_player_Computer_EnemyTeam;



    // Automatic Variable Declarations

    const int auto72333E34_ae = 4;

    const int auto72333E34_ai = 1;



    // Variable Initialization

    lv_team_EnemyTeam = libGame_gf_EnemyTeam(lp_attackingTeam);

    lv_player_Computer_EnemyTeam = libGame_gf_ComputerPlayerInTeam(lv_team_EnemyTeam);



    // Implementation

    if ((lp_attackingTeam == libGame_gv_teamOrderIndex_C)) {

        lv_index_Town[1] = 6;

        lv_index_Town[2] = 8;

        lv_index_Town[3] = 5;

        lv_index_Town[4] = 7;

    }

    else {

        lv_index_Town[1] = 2;

        lv_index_Town[2] = 4;

        lv_index_Town[3] = 1;

        lv_index_Town[4] = 3;

    }

    lv_itTown = 1;

    for ( ; ( (auto72333E34_ai >= 0 && lv_itTown <= auto72333E34_ae) || (auto72333E34_ai < 0 && lv_itTown >= auto72333E34_ae) ) ; lv_itTown += auto72333E34_ai ) {

        if ((lv_index_Town[lv_itTown] == lp_ignoredTownindex)) {

            lv_index_Town[lv_itTown] = 0;

            break;

        }



    }

    if (((libGame_gf_TownTownIsAlive(lv_index_Town[1], lv_player_Computer_EnemyTeam) == true) || (libGame_gf_TownTownIsAlive(lv_index_Town[2], lv_player_Computer_EnemyTeam) == true))) {

        lv_index_TownToAttack = libMHmu_gf_ReturnHigherHealthTown(libGame_gf_ComputerPlayerInTeam(lv_team_EnemyTeam), lv_index_Town[1], lv_index_Town[2]);

    }

    else {

        lv_index_TownToAttack = 0;

    }

    if ((lv_index_TownToAttack == 0)) {

        lv_index_TownToAttack = libMHmu_gf_ReturnHigherHealthTown(libGame_gf_ComputerPlayerInTeam(lv_team_EnemyTeam), lv_index_Town[3], lv_index_Town[4]);

    }



    return lv_index_TownToAttack;

}



unit libMHmu_gf_GetTargetForPayloadAttack (unit lp_previousTarget, int lp_team_OwnedPayload, int lp_town) {

    // Variable Declarations

    unitgroup lv_townOuterLoop;

    unitgroup lv_townOuterLoop2;

    unitgroup lv_townOuterLoop4;

    unitgroup lv_townOuterLoop3;

    unit lv_townHall;

    unitgroup lv_buildings;

    unit lv_itBuilding;



    // Automatic Variable Declarations

    unitgroup autoD11A30D2_g;

    int autoD11A30D2_u;

    int auto249030DF_val;



    // Variable Initialization

    lv_townOuterLoop = UnitGroupEmpty();

    lv_townOuterLoop2 = UnitGroupEmpty();

    lv_townOuterLoop4 = UnitGroupEmpty();

    lv_townOuterLoop3 = UnitGroupEmpty();

    lv_buildings = UnitGroupEmpty();



    // Implementation

    if ((UnitIsAlive(libGame_gv_teams[libGame_gf_EnemyTeam(lp_team_OwnedPayload)].lv_core) == false)) {

        return null;

    }



    lv_buildings = UnitGroup(null, libGame_gf_ComputerPlayerInTeam(libGame_gf_EnemyTeam(lp_team_OwnedPayload)), libGame_gv_townTownData[lp_town].lv_townRegion, UnitFilter(0, (1 << (c_targetFilterAITargetableStructure - 32)), (1 << c_targetFilterNoMinionAggro) | (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32))), 0);

    UnitGroupRemove(lv_buildings, lp_previousTarget);

    if ((lp_town == 0)) {

        return null;

    }



    autoD11A30D2_g = lv_buildings;

    autoD11A30D2_u = UnitGroupCount(autoD11A30D2_g, c_unitCountAll);

    for (;; autoD11A30D2_u -= 1) {

        lv_itBuilding = UnitGroupUnitFromEnd(autoD11A30D2_g, autoD11A30D2_u);

        if (lv_itBuilding == null) { break; }

        if ((UnitHasBehaviorWithCategoryFlag(lv_itBuilding, c_behaviorCategoryTimeStop) == false) && (UnitHasBehavior2(lv_itBuilding, "DoesNotGetTargetedByPayload") == false) && (UnitBehaviorCount(lv_itBuilding, "HanamuraPayloadStructureTarget") == 0) && ((libCore_gf_UnitStoredForUnit(lv_itBuilding, 99) != null) || (UnitHasBehaviorWithCategoryFlag(lv_itBuilding, c_behaviorCategoryDebuffStasis) == false))) {

            auto249030DF_val = libGame_gf_TownGetTownStructurePresetFromUnit(lv_itBuilding);

            if (auto249030DF_val == libGame_ge_TownStructureTypes_CannonTower) {

                UnitGroupAdd(lv_townOuterLoop, lv_itBuilding);

            }

            else if (auto249030DF_val == libGame_ge_TownStructureTypes_Gate) {

                UnitGroupAdd(lv_townOuterLoop4, lv_itBuilding);

            }

            else if (auto249030DF_val == libGame_ge_TownStructureTypes_Moonwell) {

                UnitGroupAdd(lv_townOuterLoop3, lv_itBuilding);

            }

            else if (auto249030DF_val == libGame_ge_TownStructureTypes_TownHall) {

                UnitGroupAdd(lv_townOuterLoop2, lv_itBuilding);

            }

            else {

            }

        }



    }

    if ((libNtve_gf_UnitGroupIsDead(lv_townOuterLoop) == false)) {

        return UnitGroupRandomUnit(lv_townOuterLoop, c_unitCountAlive);

    }



    if ((libNtve_gf_UnitGroupIsDead(lv_townOuterLoop4) == false)) {

        return UnitGroupRandomUnit(lv_townOuterLoop4, c_unitCountAlive);

    }



    if ((libNtve_gf_UnitGroupIsDead(lv_townOuterLoop3) == false)) {

        return UnitGroupRandomUnit(lv_townOuterLoop3, c_unitCountAlive);

    }



    if ((libNtve_gf_UnitGroupIsDead(lv_townOuterLoop2) == false)) {

        return UnitGroupRandomUnit(lv_townOuterLoop2, c_unitCountAlive);

    }



    return null;

}



void libMHmu_gf_MakePayloadAttack (int lp_attackingTeam) {

    // Variable Declarations

    int lv_missilesInFlight;

    int lv_shotspervolley;

    int lv_shotsRemaining;

    int lv_town;

    unit lv_target;

    unit lv_unusableTarget;

    int lv_unusableTown;

    fixed lv_targetLife;

    fixed lv_targetLife_FactoringInFlightMissiles;

    int lv_activeTargetPing;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_shotspervolley = 3;

    lv_shotsRemaining = libMHmu_gv_payloadShotCount_C;

    lv_activeTargetPing = c_invalidPingId;



    // Implementation

    TextExpressionSetToken("Param/Expression/lib_MHmu_3F3D0FA8", "A", IntToText(lv_shotsRemaining));

    libNtve_gf_SetDialogItemText(libNPLD_gv_hanamura.lv_attackingStructureLabel[lp_attackingTeam], TextExpressionAssemble("Param/Expression/lib_MHmu_3F3D0FA8"), PlayerGroupAll());

    TextExpressionSetToken("Param/Expression/lib_MHmu_41434967", "A", IntToText(lv_shotsRemaining));

    libNtve_gf_SetDialogItemText(libNPLD_gv_hanamura.lv_attackingStructureLabel[1], TextExpressionAssemble("Param/Expression/lib_MHmu_41434967"), PlayerGroupAll());

    TextExpressionSetToken("Param/Expression/lib_MHmu_632A78C9", "A", IntToText(lv_shotsRemaining));

    libNtve_gf_SetDialogItemText(libNPLD_gv_hanamura.lv_attackingStructureLabel[2], TextExpressionAssemble("Param/Expression/lib_MHmu_632A78C9"), PlayerGroupAll());

    lv_town = libMHmu_gf_GetTownForPayloadAttack(lv_unusableTown, lp_attackingTeam);

    lv_target = libMHmu_gf_GetTargetForPayloadAttack(lv_target, lp_attackingTeam, lv_town);

    while ((lv_shotsRemaining > 0)) {

        if ((libGame_gv_gameOver == true)) {

            return ;

        }



        while (!((UnitHasBehaviorWithCategoryFlag(libNPLD_gv_neutralPayload.lv_unit, c_behaviorCategoryDebuffStasis) == false) && (UnitHasBehaviorWithCategoryFlag(libNPLD_gv_neutralPayload.lv_unit, c_behaviorCategoryTimeStop) == false))) {

            Wait(0.625, c_timeGame);

        }

        if (((libGame_gf_TownTownIsAlive(lv_town, libGame_gf_ComputerPlayerInTeam(libGame_gf_EnemyTeam(lp_attackingTeam))) == false) || (lv_unusableTown == lv_town))) {

            lv_town = libMHmu_gf_GetTownForPayloadAttack(lv_unusableTown, lp_attackingTeam);

            lv_unusableTown = 0;

            lv_target = null;

            lv_target = libMHmu_gf_GetTargetForPayloadAttack(lv_target, lp_attackingTeam, lv_town);

        }

        else {

            if ((lv_unusableTarget == lv_target)) {

                lv_target = libMHmu_gf_GetTargetForPayloadAttack(lv_unusableTarget, lp_attackingTeam, lv_town);

                lv_unusableTarget = null;

            }



            if ((lv_target == null)) {

                lv_unusableTown = lv_town;

                continue;

            }



        }

        if ((lv_town == 0)) {

            lv_target = libGame_gv_teams[libGame_gf_EnemyTeam(lp_attackingTeam)].lv_core;

        }



        lv_targetLife = libCore_gf_GetTotalHPForUnitIncludingAllShields(lv_target);

        lv_missilesInFlight = UnitBehaviorCount(lv_target, "HanamuraPayloadStructureTarget");

        lv_targetLife_FactoringInFlightMissiles = (lv_targetLife - (StringToFixed(CatalogFieldValueGet(c_gameCatalogEffect, "Payload_AttackDamage", "Amount", 0)) * lv_missilesInFlight));

        if (((lv_target != libGame_gv_teams[libGame_gf_EnemyTeam(lp_attackingTeam)].lv_core) && ((UnitIsAlive(lv_target) == false) || (UnitIsValid(lv_target) == false) || (lv_target == null) || (UnitHasBehavior2(lv_target, "TownCannonTowerInvulnerable") == true) || (lv_targetLife_FactoringInFlightMissiles < 0.0) || (UnitHasBehaviorWithCategoryFlag(lv_target, c_behaviorCategoryTimeStop) == true) || ((UnitHasBehaviorWithCategoryFlag(lv_target, c_behaviorCategoryDebuffStasis) == true) && (libCore_gf_UnitStoredForUnit(lv_target, 99) == null))))) {

            lv_unusableTarget = lv_target;

            continue;

        }

        else {

            UnitCreateEffectUnit(libNPLD_gv_neutralPayload.lv_unit, "PayloadAttackCoreModifyTurret", lv_target);

            Wait(0.25, c_timeGame);

        }

        if ((lv_target == libGame_gv_teams[libGame_gf_EnemyTeam(lp_attackingTeam)].lv_core)) {

            while (!(((UnitHasBehaviorWithCategoryFlag(lv_target, c_behaviorCategoryDebuffStasis) == false) && (UnitHasBehaviorWithCategoryFlag(lv_target, c_behaviorCategoryTimeStop) == false) && (UnitHasBehaviorWithCategoryFlag(lv_target, c_behaviorCategoryInvulnerable) == false)))) {

                Wait(0.625, c_timeGame);

            }

        }



        if ((libCore_gf_PingStoredForUnit(lv_target, 1) == c_invalidPingId)) {

            libCore_gf_CreateMinimapPingStorm(PlayerGroupAll(), "StormGhostShipImpact", UnitGetPosition(lv_target), ColorWithAlpha(100.00, 0.00, 0.00, 0.00), 3.0);

            libCore_gf_StorePingForUnit(lv_target, 1, PingLastCreated());

        }



        UnitBehaviorAdd(lv_target, ("HanamuraPayloadStructureTarget"), libNPLD_gv_neutralPayload.lv_unit, 1);

        UnitCreateEffectUnit(libNPLD_gv_neutralPayload.lv_unit, "Payload_AttackLM", lv_target);

        lv_shotsRemaining -= 1;

        TextExpressionSetToken("Param/Expression/lib_MHmu_A58E51F2", "A", IntToText(lv_shotsRemaining));

        libNtve_gf_SetDialogItemText(libNPLD_gv_hanamura.lv_attackingStructureLabel[lp_attackingTeam], TextExpressionAssemble("Param/Expression/lib_MHmu_A58E51F2"), PlayerGroupAll());

        TextExpressionSetToken("Param/Expression/lib_MHmu_36601B3C", "A", IntToText(lv_shotsRemaining));

        libNtve_gf_SetDialogItemText(libNPLD_gv_hanamura.lv_attackingStructureLabel[1], TextExpressionAssemble("Param/Expression/lib_MHmu_36601B3C"), PlayerGroupAll());

        TextExpressionSetToken("Param/Expression/lib_MHmu_C22502E9", "A", IntToText(lv_shotsRemaining));

        libNtve_gf_SetDialogItemText(libNPLD_gv_hanamura.lv_attackingStructureLabel[2], TextExpressionAssemble("Param/Expression/lib_MHmu_C22502E9"), PlayerGroupAll());

        Wait(0.5, c_timeGame);

        if ((ModI(lv_shotsRemaining, lv_shotspervolley) == 0)) {

            Wait(2.0, c_timeGame);

        }



    }

    UnitCreateEffectPoint(libNPLD_gv_neutralPayload.lv_unit, "PayloadAttackCoreClearTurret", PointWithOffsetPolar(UnitGetPosition(libNPLD_gv_neutralPayload.lv_unit), 1.0, UnitGetFacing(libNPLD_gv_neutralPayload.lv_unit)));

    Wait(2.0, c_timeGame);

    DialogControlSetVisible(libNPLD_gv_hanamura.lv_attackingStructureFrame[lp_attackingTeam], PlayerGroupAll(), false);

    Wait(2.0, c_timeGame);

    DialogControlSetVisible(libNPLD_gv_hanamura.lv_payloadPanel, PlayerGroupAll(), false);

    TextExpressionSetToken("Param/Expression/lib_MHmu_87700DF8", "A", IntToText(libMHmu_gv_payloadShotCount_C));

    libNtve_gf_SetDialogItemText(libNPLD_gv_hanamura.lv_attackingStructureLabel[1], TextExpressionAssemble("Param/Expression/lib_MHmu_87700DF8"), PlayerGroupAll());

    TextExpressionSetToken("Param/Expression/lib_MHmu_47FB8954", "A", IntToText(libMHmu_gv_payloadShotCount_C));

    libNtve_gf_SetDialogItemText(libNPLD_gv_hanamura.lv_attackingStructureLabel[2], TextExpressionAssemble("Param/Expression/lib_MHmu_47FB8954"), PlayerGroupAll());

}



trigger auto_libMHmu_gf_ElevatorAddRemoveUnpathableUnit_Trigger = null;

bool auto_libMHmu_gf_ElevatorAddRemoveUnpathableUnit_lp_addRemove;



void libMHmu_gf_ElevatorAddRemoveUnpathableUnit (bool lp_addRemove) {

    auto_libMHmu_gf_ElevatorAddRemoveUnpathableUnit_lp_addRemove = lp_addRemove;



    if (auto_libMHmu_gf_ElevatorAddRemoveUnpathableUnit_Trigger == null) {

        auto_libMHmu_gf_ElevatorAddRemoveUnpathableUnit_Trigger = TriggerCreate("auto_libMHmu_gf_ElevatorAddRemoveUnpathableUnit_TriggerFunc");

    }



    TriggerExecute(auto_libMHmu_gf_ElevatorAddRemoveUnpathableUnit_Trigger, false, false);

}



bool auto_libMHmu_gf_ElevatorAddRemoveUnpathableUnit_TriggerFunc (bool testConds, bool runActions) {

    bool lp_addRemove = auto_libMHmu_gf_ElevatorAddRemoveUnpathableUnit_lp_addRemove;



    // Automatic Variable Declarations

    unitgroup autoCFEAF2C8_g;

    int autoCFEAF2C8_u;

    unit autoCFEAF2C8_var;



    // Implementation

    if ((lp_addRemove == true)) {

        if ((libMHmu_gv_elevator_PathingBlocker_Unit == null)) {

            libNtve_gf_CreateUnitsWithDefaultFacing(1, "Elevator_PathingBlocker", c_unitCreateIgnorePlacement, libCore_gv_cOMPUTER_Hostile, libMHmu_gv_elevator_Point, null);

            libMHmu_gv_elevator_PathingBlocker_Unit = UnitLastCreated();

            autoCFEAF2C8_g = UnitGroup(null, c_playerAny, libMHmu_gv_elevator_Region, UnitFilter((1 << c_targetFilterVisible), 0, (1 << c_targetFilterAir) | (1 << c_targetFilterHeroic) | (1 << c_targetFilterUser1) | (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)) | (1 << (c_targetFilterMapCreature - 32))), 0);

            autoCFEAF2C8_u = UnitGroupCount(autoCFEAF2C8_g, c_unitCountAll);

            for (;; autoCFEAF2C8_u -= 1) {

                autoCFEAF2C8_var = UnitGroupUnitFromEnd(autoCFEAF2C8_g, autoCFEAF2C8_u);

                if (autoCFEAF2C8_var == null) { break; }

                if ((UnitFilterMatch(autoCFEAF2C8_var, 0, UnitFilter(0, (1 << (c_targetFilterSummoned - 32)), 0, 0)) == true)) {

                    UnitKill(autoCFEAF2C8_var);

                }

                else {

                    UnitSetPosition(autoCFEAF2C8_var, PointWithOffsetPolar(RegionGetCenter(libMHmu_gv_elevator_Region), 3.0, libNtve_gf_RandomAngle()), false);

                }

            }

            Wait(5.0, c_timeGame);

            UnitCreateEffectPoint(libMHmu_gv_elevator_PathingBlocker_Unit, "ElevatorPayloadAttachmentDummy", libNPLD_gv_neutralPayload.lv_pathWaypoints[libGame_gv_teamOrderIndex_C][libNPLD_gv_neutralPayload.lv_pathIndex_Team[libGame_gv_teamOrderIndex_C]][1]);

        }



    }

    else {

        ActorSendTo(libNtve_gf_MainActorofUnit(libMHmu_gv_elevator_PathingBlocker_Unit), "::global.PayloadElevatorAttachment", "SetTintColor 0,255,255");

        UnitRemove(libMHmu_gv_elevator_PathingBlocker_Unit);

        libMHmu_gv_elevator_PathingBlocker_Unit = null;

        libMHmu_gv_elevator_WaitingToLower = false;

    }

    return true;

}



trigger auto_libMHmu_gf_ElevatorAttempttoLowerMonitor_Trigger = null;



void libMHmu_gf_ElevatorAttempttoLowerMonitor () {

    if (auto_libMHmu_gf_ElevatorAttempttoLowerMonitor_Trigger == null) {

        auto_libMHmu_gf_ElevatorAttempttoLowerMonitor_Trigger = TriggerCreate("auto_libMHmu_gf_ElevatorAttempttoLowerMonitor_TriggerFunc");

    }



    TriggerExecute(auto_libMHmu_gf_ElevatorAttempttoLowerMonitor_Trigger, false, false);

}



bool auto_libMHmu_gf_ElevatorAttempttoLowerMonitor_TriggerFunc (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_itUnit;

    unit lv_itHeroUnit;

    fixed lv_elevatorCalculatedTimer;



    // Automatic Variable Declarations

    const int auto95E1F680_n = 5;

    int auto95E1F680_i;

    unitgroup auto10FF810F_g;

    int auto10FF810F_u;



    // Variable Initialization



    // Implementation

    Wait(5.0, c_timeGame);

    lv_elevatorCalculatedTimer = (libMHmu_gv_mapMechanic_CooldownTimer_Duration - libMHmu_gv_mapMechanic_WarningTimer_Duration);

    lv_elevatorCalculatedTimer -= libMHmu_gv_elevator.lv_elevatorLowerTime;

    libMHmu_gv_elevator_WaitingToLower = true;

    TimerStart(libMHmu_gv_elevator_Forced_Lower_Timer, lv_elevatorCalculatedTimer, false, c_timeGame);

    while (!(((libMHmu_gv_elevator_WaitingToLower == false) || ((UnitGroupCount(UnitGroup(null, c_playerAny, libMHmu_gv_elevator_Region, UnitFilter((1 << c_targetFilterHeroic), 0, 0, 0), 0), c_unitCountAlive) == 0) && (UnitGroupCount(UnitGroup(null, c_playerAny, libMHmu_gv_elevator_Region, UnitFilter(0, (1 << (c_targetFilterSummoned - 32)), 0, 0), 0), c_unitCountAlive) == 0) && (UnitGroupCount(UnitGroup(null, c_playerAny, libMHmu_gv_elevator_Region, UnitFilter((1 << c_targetFilterMinion), 0, 0, 0), 0), c_unitCountAlive) == 0) && (UnitGroupCount(UnitGroup(null, c_playerAny, libMHmu_gv_elevator_Region, UnitFilter((1 << c_targetFilterCreep), 0, 0, 0), 0), c_unitCountAlive) == 0))))) {

        Wait(0.125, c_timeGame);

    }

    libMHmu_gv_elevator_WaitingToLower = false;

    libMHmu_gf_ElevatorAddRemoveUnpathableUnit(true);

    ActorSend(ActorFromDoodad(libMHmu_gv_elevator_Doodad), "Signal Down");

    for (auto95E1F680_i = 1; auto95E1F680_i <= auto95E1F680_n; auto95E1F680_i += 1) {

        auto10FF810F_g = UnitGroup(null, c_playerAny, libMHmu_gv_elevator_Region, libCore_gv_filtersHeroic, 0);

        auto10FF810F_u = UnitGroupCount(auto10FF810F_g, c_unitCountAll);

        for (;; auto10FF810F_u -= 1) {

            lv_itHeroUnit = UnitGroupUnitFromEnd(auto10FF810F_g, auto10FF810F_u);

            if (lv_itHeroUnit == null) { break; }

            UnitCreateEffectUnit(lv_itHeroUnit, "HeroGenericMissileInterruptLaunchMissile", lv_itHeroUnit);

        }

    }

    return true;

}



trigger auto_libMHmu_gf_PayloadSpawning_Trigger = null;



void libMHmu_gf_PayloadSpawning () {

    if (auto_libMHmu_gf_PayloadSpawning_Trigger == null) {

        auto_libMHmu_gf_PayloadSpawning_Trigger = TriggerCreate("auto_libMHmu_gf_PayloadSpawning_TriggerFunc");

    }



    TriggerExecute(auto_libMHmu_gf_PayloadSpawning_Trigger, false, false);

}



bool auto_libMHmu_gf_PayloadSpawning_TriggerFunc (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Implementation

    if ((libGame_gv_gameOver == true)) {

        return true;

    }



    TriggerQueueEnter();

    UserDataResetType("MapVOEvent");

    ConversationDataLineResetPlayers("HanamuraVO", ("Left"));

    ConversationDataLineResetPlayers("HanamuraVO", ("Right"));

    ConversationDataLineResetPlayers("HanamuraVO", ("Observer"));

    if ((libMHmu_gv_hanamura.lv_mapMechanic_FirstPayloadSpawned == false)) {

        UserDataSetInt("MapVOEvent", "Hanamura - Payload Spawning First", "Value", 1, 1);

        libMHmu_gv_hanamura.lv_mapMechanic_FirstPayloadSpawned = true;

    }

    else {

        UserDataSetInt("MapVOEvent", "Hanamura - Payload Spawning Left", "Value", 1, 1);

    }

    ConversationDataRun("HanamuraVO", PlayerGroupAll(), c_conversationSkipNone, false);

    libCore_gf_WaitForConversationToFinish();

    TriggerQueueExit();

    return true;

}



trigger auto_libMHmu_gf_PayloadsSpawned_Trigger = null;



void libMHmu_gf_PayloadsSpawned () {

    if (auto_libMHmu_gf_PayloadsSpawned_Trigger == null) {

        auto_libMHmu_gf_PayloadsSpawned_Trigger = TriggerCreate("auto_libMHmu_gf_PayloadsSpawned_TriggerFunc");

    }



    TriggerExecute(auto_libMHmu_gf_PayloadsSpawned_Trigger, false, false);

}



bool auto_libMHmu_gf_PayloadsSpawned_TriggerFunc (bool testConds, bool runActions) {

    // Variable Declarations

    playergroup lv_groupOrder;

    playergroup lv_groupChaos;

    playergroup lv_groupObserver;

    int lv_itLineIndex;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_groupOrder = PlayerGroupEmpty();

    lv_groupChaos = PlayerGroupEmpty();

    lv_groupObserver = PlayerGroupEmpty();



    // Implementation

    if ((libGame_gv_gameOver == true)) {

        return true;

    }



    TriggerQueueEnter();

    UserDataResetType("MapVOEvent");

    ConversationDataLineResetPlayers("HanamuraVO", ("Left"));

    ConversationDataLineResetPlayers("HanamuraVO", ("Right"));

    ConversationDataLineResetPlayers("HanamuraVO", ("Observer"));

    if ((libMHmu_gv_hanamura.lv_mapMechanic_FirstPayloadSpawned == false)) {

        UserDataSetInt("MapVOEvent", "Hanamura - Payload Spawn First", "Value", 1, 1);

    }

    else {

        UserDataSetInt("MapVOEvent", "Hanamura - Payload Spawn Left", "Value", 1, 1);

    }

    ConversationDataRun("HanamuraVO", PlayerGroupAll(), c_conversationSkipNone, false);

    libCore_gf_WaitForConversationToFinish();

    TriggerQueueExit();

    return true;

}



trigger auto_libMHmu_gf_PayloadsPathCompletedOrder_Trigger = null;



void libMHmu_gf_PayloadsPathCompletedOrder () {

    if (auto_libMHmu_gf_PayloadsPathCompletedOrder_Trigger == null) {

        auto_libMHmu_gf_PayloadsPathCompletedOrder_Trigger = TriggerCreate("auto_libMHmu_gf_PayloadsPathCompletedOrder_TriggerFunc");

    }



    TriggerExecute(auto_libMHmu_gf_PayloadsPathCompletedOrder_Trigger, false, false);

}



bool auto_libMHmu_gf_PayloadsPathCompletedOrder_TriggerFunc (bool testConds, bool runActions) {

    // Variable Declarations

    playergroup lv_groupOrder;

    playergroup lv_groupChaos;

    playergroup lv_groupObserver;

    int lv_itLineIndex;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_groupOrder = PlayerGroupEmpty();

    lv_groupChaos = PlayerGroupEmpty();

    lv_groupObserver = PlayerGroupEmpty();



    // Implementation

    if ((libGame_gv_gameOver == true)) {

        return true;

    }



    TriggerQueueEnter();

    UserDataResetType("MapVOEvent");

    ConversationDataLineResetPlayers("HanamuraVO", ("Left"));

    ConversationDataLineResetPlayers("HanamuraVO", ("Right"));

    ConversationDataLineResetPlayers("HanamuraVO", ("Observer"));

    UserDataSetInt("MapVOEvent", "Hanamura - Payload End Left", "Value", 1, 1);

    lv_groupOrder = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamOrderIndex_C, false);

    lv_groupChaos = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamChaosIndex_C, false);

    lv_groupObserver = libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer];

    ConversationDataLineSetPlayers("HanamuraVO", ("Left"), lv_groupOrder);

    ConversationDataLineSetPlayers("HanamuraVO", ("Right"), lv_groupChaos);

    ConversationDataLineSetPlayers("HanamuraVO", ("Observer"), lv_groupObserver);

    ConversationDataRun("HanamuraVO", PlayerGroupAll(), c_conversationSkipNone, false);

    libCore_gf_WaitForConversationToFinish();

    TriggerQueueExit();

    return true;

}



trigger auto_libMHmu_gf_PayloadsPathCompletedChaos_Trigger = null;



void libMHmu_gf_PayloadsPathCompletedChaos () {

    if (auto_libMHmu_gf_PayloadsPathCompletedChaos_Trigger == null) {

        auto_libMHmu_gf_PayloadsPathCompletedChaos_Trigger = TriggerCreate("auto_libMHmu_gf_PayloadsPathCompletedChaos_TriggerFunc");

    }



    TriggerExecute(auto_libMHmu_gf_PayloadsPathCompletedChaos_Trigger, false, false);

}



bool auto_libMHmu_gf_PayloadsPathCompletedChaos_TriggerFunc (bool testConds, bool runActions) {

    // Variable Declarations

    playergroup lv_groupOrder;

    playergroup lv_groupChaos;

    playergroup lv_groupObserver;

    int lv_itLineIndex;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_groupOrder = PlayerGroupEmpty();

    lv_groupChaos = PlayerGroupEmpty();

    lv_groupObserver = PlayerGroupEmpty();



    // Implementation

    if ((libGame_gv_gameOver == true)) {

        return true;

    }



    TriggerQueueEnter();

    UserDataResetType("MapVOEvent");

    ConversationDataLineResetPlayers("HanamuraVO", ("Left"));

    ConversationDataLineResetPlayers("HanamuraVO", ("Right"));

    ConversationDataLineResetPlayers("HanamuraVO", ("Observer"));

    UserDataSetInt("MapVOEvent", "Hanamura - Payload End Right", "Value", 1, 1);

    lv_groupOrder = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamOrderIndex_C, false);

    lv_groupChaos = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamChaosIndex_C, false);

    lv_groupObserver = libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer];

    ConversationDataLineSetPlayers("HanamuraVO", ("Left"), lv_groupOrder);

    ConversationDataLineSetPlayers("HanamuraVO", ("Right"), lv_groupChaos);

    ConversationDataLineSetPlayers("HanamuraVO", ("Observer"), lv_groupObserver);

    ConversationDataRun("HanamuraVO", PlayerGroupAll(), c_conversationSkipNone, false);

    libCore_gf_WaitForConversationToFinish();

    TriggerQueueExit();

    return true;

}



trigger auto_libMHmu_gf_ShowWarningTimer_Trigger = null;



void libMHmu_gf_ShowWarningTimer () {

    if (auto_libMHmu_gf_ShowWarningTimer_Trigger == null) {

        auto_libMHmu_gf_ShowWarningTimer_Trigger = TriggerCreate("auto_libMHmu_gf_ShowWarningTimer_TriggerFunc");

    }



    TriggerExecute(auto_libMHmu_gf_ShowWarningTimer_Trigger, false, false);

}



bool auto_libMHmu_gf_ShowWarningTimer_TriggerFunc (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Implementation

    DialogControlSetVisible(libNPLD_gv_hanamura.lv_warningTimerFrame, PlayerGroupAll(), true);

    while ((TimerGetRemaining(libMHmu_gv_hanamura.lv_mapMechanic_ObjectivePreviewDelay) > 0.5)) {

        libNtve_gf_SetDialogItemText(libNPLD_gv_hanamura.lv_warningTimerLabel, FixedToText(TimerGetRemaining(libMHmu_gv_hanamura.lv_mapMechanic_ObjectivePreviewDelay), 0), PlayerGroupAll());

        Wait(0.0625, c_timeGame);

    }

    libNtve_gf_SetDialogItemText(libNPLD_gv_hanamura.lv_warningTimerLabel, FixedToText(0.0, 0), PlayerGroupAll());

    DialogControlSendAnimationEvent(libNPLD_gv_hanamura.lv_warningTimerFrame, PlayerGroupAll(), "AnimateOut");

    Wait(0.5, c_timeGame);

    DialogControlSetVisible(libNPLD_gv_hanamura.lv_warningTimerFrame, PlayerGroupAll(), false);

    return true;

}



void libMHmu_gf_ShowWarningIndicator (int lp_team) {

    // Variable Declarations

    int lv_pathIndex;

    int lv_destinationIndex;

    string lv_unitType;



    // Automatic Variable Declarations

    int autoB5A2216A_val;



    // Variable Initialization

    lv_pathIndex = libNPLD_gv_neutralPayload.lv_pathIndex_Team[lp_team];

    lv_destinationIndex = libNPLD_gv_neutralPayload.lv_pathWaypoints_DestinationIndex[lp_team][lv_pathIndex];



    // Implementation

    autoB5A2216A_val = lv_pathIndex;

    if (autoB5A2216A_val == 1) {

        lv_unitType = "ControlPointMinimapPreviewIconB";

    }

    else if (autoB5A2216A_val == 2) {

        lv_unitType = "ControlPointMinimapPreviewIconC";

    }

    else if (autoB5A2216A_val == 3) {

        lv_unitType = "ControlPointMinimapPreviewIconA";

    }

    else {

    }

    libNtve_gf_CreateUnitsWithDefaultFacing(1, lv_unitType, c_unitCreateIgnorePlacement, libGame_gf_ComputerPlayerInTeam(lp_team), libNPLD_gv_neutralPayload.lv_pathWaypoints[lp_team][lv_pathIndex][libNPLD_gv_neutralPayload.lv_pathWaypoints_DestinationIndex[lp_team][lv_pathIndex]], null);

    libMHmu_gv_hanamura.lv_mapMechanic_PreviewUnit[lp_team] = UnitLastCreated();

}



void libMHmu_gf_ShowDestinationIndicator (int lp_team) {

    // Variable Declarations

    int lv_pathIndex;

    int lv_destinationIndex;

    string lv_unitType;

    fixed lv_facing;



    // Automatic Variable Declarations

    int autoCC6C6325_val;



    // Variable Initialization

    lv_pathIndex = libNPLD_gv_neutralPayload.lv_pathIndex_Team[lp_team];

    lv_destinationIndex = libNPLD_gv_neutralPayload.lv_pathWaypoints_DestinationIndex[lp_team][lv_pathIndex];



    // Implementation

    UnitKill(libMHmu_gv_hanamura.lv_mapMechanic_PreviewUnit[lp_team]);

    autoCC6C6325_val = lv_pathIndex;

    if (autoCC6C6325_val == 1) {

        lv_unitType = "ControlPointMinimapIconB";

    }

    else if (autoCC6C6325_val == 2) {

        lv_unitType = "ControlPointMinimapIconC";

    }

    else if (autoCC6C6325_val == 3) {

        lv_unitType = "ControlPointMinimapIconA";

        lv_facing = 90.0;

    }

    else {

    }

    libNtve_gf_CreateUnitsWithDefaultFacing(1, lv_unitType, c_unitCreateIgnorePlacement, libGame_gf_ComputerPlayerInTeam(lp_team), libNPLD_gv_neutralPayload.lv_pathWaypoints[lp_team][lv_pathIndex][libNPLD_gv_neutralPayload.lv_pathWaypoints_DestinationIndex[lp_team][lv_pathIndex]], null);

    libMHmu_gv_hanamura.lv_mapMechanic_DestinationUnit[lp_team] = UnitLastCreated();

}



void libMHmu_gf_DestroyDestinationIndicator (int lp_team) {

    // Variable Declarations

    int lv_pathIndex;

    int lv_destinationIndex;

    string lv_unitType;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_pathIndex = libNPLD_gv_neutralPayload.lv_pathIndex_Team[lp_team];

    lv_destinationIndex = libNPLD_gv_neutralPayload.lv_pathWaypoints_DestinationIndex[lp_team][lv_pathIndex];



    // Implementation

    UnitKill(libMHmu_gv_hanamura.lv_mapMechanic_DestinationUnit[lp_team]);

}



void libMHmu_gf_EOMInitializeEndofMatchAward () {

    // Variable Declarations

    int lv_iterator;



    // Automatic Variable Declarations

    int auto7398B425_ae;



    // Variable Initialization



    // Implementation

    auto7398B425_ae = libCore_gv_bALMaxPlayers;

    lv_iterator = 1;

    for ( ; lv_iterator <= auto7398B425_ae ; lv_iterator += 1 ) {

        TimerStart(libMHmu_gv_eOMPusherTimer[lv_iterator], c_timerDurationInfinite, false, c_timeGame);

        TimerPause(TimerLastStarted(), true);

    }

    libGame_gf_SendMapSpecificAwardInitializeEventwithUserData(null, "Generic Instance");

}



int libMHmu_gf_ppathGetPathID (string lp_inputString) {

    // Automatic Variable Declarations

    string autoE70FAC27_val;



    // Implementation

    autoE70FAC27_val = lp_inputString;

    if (autoE70FAC27_val == "A") {

        return 3;

    }

    else if (autoE70FAC27_val == "a") {

        return 3;

    }

    else if (autoE70FAC27_val == "1") {

        return 3;

    }

    else if (autoE70FAC27_val == "B") {

        return 1;

    }

    else if (autoE70FAC27_val == "b") {

        return 1;

    }

    else if (autoE70FAC27_val == "2") {

        return 1;

    }

    else if (autoE70FAC27_val == "C") {

        return 2;

    }

    else if (autoE70FAC27_val == "c") {

        return 2;

    }

    else if (autoE70FAC27_val == "3") {

        return 2;

    }

    else {

        return 0;

    }

}



// Triggers

//--------------------------------------------------------------------------------------------------

// Trigger: Hanamura Core - Barrage Proc

//--------------------------------------------------------------------------------------------------

bool libMHmu_gt_HanamuraCoreBarrageProc_Func (bool testConds, bool runActions) {

    // Variable Declarations

    point lv_p;

    int lv_i;

    unit lv_core;

    int lv_coreOwner;



    // Automatic Variable Declarations

    int autoAAF3A068_ae;



    // Variable Initialization

    lv_core = EventPlayerEffectUsedUnit(c_effectUnitCaster);

    lv_coreOwner = UnitGetOwner(lv_core);



    // Actions

    if (!runActions) {

        return true;

    }



    autoAAF3A068_ae = libMHmu_gv_hanamuraCoreBarrageCount;

    lv_i = 1;

    for ( ; lv_i <= autoAAF3A068_ae ; lv_i += 1 ) {

        lv_p = UnitTypePlacementFromPoint("HanamuraCoreAttackRadiusDummy", lv_coreOwner, RegionRandomPoint(RegionCircle(UnitGetPosition(lv_core), 10.0)), 10.0);

        UnitCreateEffectPointWithSource(lv_core, "HanamuraCoreBarrageLaunchPersistent", lv_p, c_gameCatalogAbil, "HanamuraCoreBarrage");

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libMHmu_gt_HanamuraCoreBarrageProc_Init () {

    libMHmu_gt_HanamuraCoreBarrageProc = TriggerCreate("libMHmu_gt_HanamuraCoreBarrageProc_Func");

    TriggerAddEventPlayerEffectUsed(libMHmu_gt_HanamuraCoreBarrageProc, c_playerAny, "HanamuraCoreBarrageDummySet");

}



//--------------------------------------------------------------------------------------------------

// Trigger: Map Initialization

//--------------------------------------------------------------------------------------------------

bool libMHmu_gt_MapInitialization_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Actions

    if (!runActions) {

        return true;

    }



    libMHmu_gf_InitSwordsmanMercCampBruiserCamp1();

    if ((libMHmu_gv_hanamuraUseVisionCamps == true)) {

        libMHmu_gf_InitVisionMercCampBruiserCamp3();

    }

    else {

        libMHmu_gf_InitKnightsMercCampBruiserCamp3();

    }

    libUIUI_gf_PingCreateNewPingTarget("Payload_Neutral", false, StringExternal("Param/Value/lib_MHmu_A5C3D854"), StringExternal("Param/Value/lib_MHmu_B3436071"), StringExternal("Param/Value/lib_MHmu_3DEE864E"), SoundLink("UI_Game_Ping_Defend", -1), SoundLink("UI_Game_Ping_Attack", -1));

    libMHmu_gv_payloadPaths[libGame_gv_teamOrderIndex_C][3] = "HanamuraPayloadPath1Order";

    libMHmu_gv_payloadPaths[libGame_gv_teamOrderIndex_C][1] = "HanamuraPayloadPath2Order";

    libMHmu_gv_payloadPaths[libGame_gv_teamOrderIndex_C][2] = "HanamuraPayloadPath3Order";

    libMHmu_gv_payloadPaths[libGame_gv_teamChaosIndex_C][3] = "HanamuraPayloadPath1Chaos";

    libMHmu_gv_payloadPaths[libGame_gv_teamChaosIndex_C][1] = "HanamuraPayloadPath2Chaos";

    libMHmu_gv_payloadPaths[libGame_gv_teamChaosIndex_C][2] = "HanamuraPayloadPath3Chaos";

    libOVER_gv_overwatchModExtraScalingEnabled = false;

    return true;

}



//--------------------------------------------------------------------------------------------------

void libMHmu_gt_MapInitialization_Init () {

    libMHmu_gt_MapInitialization = TriggerCreate("libMHmu_gt_MapInitialization_Func");

    TriggerAddEventMapInit(libMHmu_gt_MapInitialization);

}



//--------------------------------------------------------------------------------------------------

// Trigger: Map Mechanic Initialized

//--------------------------------------------------------------------------------------------------

bool libMHmu_gt_MapMechanicInitialized_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_itPlayer;



    // Automatic Variable Declarations

    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libGame_gf_MapMechanicInitializationMechanicType() == libMHmu_gv_hanamuraMechanicName_C))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    TriggerExecute(libMHmu_gt_InitializeMinionData, true, false);

    TriggerExecute(libMHmu_gt_InitializeMinionScalingData, true, false);

    libMHmu_gf_EOMInitializeEndofMatchAward();

    return true;

}



//--------------------------------------------------------------------------------------------------

void libMHmu_gt_MapMechanicInitialized_Init () {

    libMHmu_gt_MapMechanicInitialized = TriggerCreate("libMHmu_gt_MapMechanicInitialized_Func");

    libGame_gf_MapMechanicInitialization(libMHmu_gt_MapMechanicInitialized);

}



//--------------------------------------------------------------------------------------------------

// Trigger: Open The Gates Timer Expires

//--------------------------------------------------------------------------------------------------

bool libMHmu_gt_OpenTheGatesTimerExpires_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libMapM_gv_mMMapMechanicDisabled == false))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    TimerStart(libMHmu_gv_hanamura.lv_mapMechanic_ObjectivePreviewTimer, (libMHmu_gv_mapMechanic_CooldownTimer_Duration - libMHmu_gv_mapMechanic_WarningTimer_Duration), false, c_timeGame);

    libSond_gf_SoundtrackApplyNewDefaultSoundtrackForPlayerGroup("MX_Hanamura_GameStart", PlayerGroupAll());

    return true;

}



//--------------------------------------------------------------------------------------------------

void libMHmu_gt_OpenTheGatesTimerExpires_Init () {

    libMHmu_gt_OpenTheGatesTimerExpires = TriggerCreate("libMHmu_gt_OpenTheGatesTimerExpires_Func");

    TriggerAddEventTimer(libMHmu_gt_OpenTheGatesTimerExpires, libGame_gv_openTheGatesTimer);

}



//--------------------------------------------------------------------------------------------------

// Trigger: Map Mechanic Timer Expires

//--------------------------------------------------------------------------------------------------

bool libMHmu_gt_MapMechanicTimerExpires_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Actions

    if (!runActions) {

        return true;

    }



    libNPLD_gf_ShowPayloadPath_Warning();

    libMHmu_gf_PayloadSpawning();

    libMHmu_gf_ShowWarningIndicator(libGame_gv_teamOrderIndex_C);

    libMHmu_gf_ShowWarningIndicator(libGame_gv_teamChaosIndex_C);

    TimerStart(libMHmu_gv_hanamuraMM10secondcountdownTimer, (libMHmu_gv_mapMechanic_WarningTimer_Duration - 10.5), false, c_timeGame);

    TimerStart(libMHmu_gv_hanamura.lv_mapMechanic_ObjectivePreviewDelay, libMHmu_gv_mapMechanic_WarningTimer_Duration, false, c_timeGame);

    TimerStart(libMHmu_gv_elevator.lv_elevatorRaiseTimer, (libMHmu_gv_mapMechanic_WarningTimer_Duration - 8.0), false, c_timeGame);

    AddPointOfInterest(libNPLD_gv_neutralPayload.lv_pathWaypoints_StartLocation, 8.0, 20.0, "PrepareForPayload", libNtve_ge_GoalTeam_Both, 0);

    libMHmu_gf_ShowWarningTimer();

    libSond_gf_SoundtrackApplyNewDefaultSoundtrackForPlayerGroup("MX_Hanamura_EventWarning", PlayerGroupAll());

    return true;

}



//--------------------------------------------------------------------------------------------------

void libMHmu_gt_MapMechanicTimerExpires_Init () {

    libMHmu_gt_MapMechanicTimerExpires = TriggerCreate("libMHmu_gt_MapMechanicTimerExpires_Func");

    TriggerAddEventTimer(libMHmu_gt_MapMechanicTimerExpires, libMHmu_gv_hanamura.lv_mapMechanic_ObjectivePreviewTimer);

}



//--------------------------------------------------------------------------------------------------

// Trigger: Map Mechanic Warning Expires

//--------------------------------------------------------------------------------------------------

bool libMHmu_gt_MapMechanicWarningExpires_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Actions

    if (!runActions) {

        return true;

    }



    libMHmu_gf_ElevatorAddRemoveUnpathableUnit(false);

    DialogControlSetVisible(libNPLD_gv_hanamura.lv_payloadPanel, PlayerGroupAll(), true);

    libNPLD_gf_CreateNeutralPayload();

    libMHmu_gf_ShowDestinationIndicator(libGame_gv_teamOrderIndex_C);

    libMHmu_gf_ShowDestinationIndicator(libGame_gv_teamChaosIndex_C);

    libMHmu_gf_PayloadsSpawned();

    libSond_gf_SoundtrackApplyNewDefaultSoundtrackForPlayerGroup("MX_Hanamura_Event", PlayerGroupAll());

    return true;

}



//--------------------------------------------------------------------------------------------------

void libMHmu_gt_MapMechanicWarningExpires_Init () {

    libMHmu_gt_MapMechanicWarningExpires = TriggerCreate("libMHmu_gt_MapMechanicWarningExpires_Func");

    TriggerAddEventTimer(libMHmu_gt_MapMechanicWarningExpires, libMHmu_gv_hanamura.lv_mapMechanic_ObjectivePreviewDelay);

}



//--------------------------------------------------------------------------------------------------

// Trigger: Map Mechanic - 10 Second Countdown Timer Expires

//--------------------------------------------------------------------------------------------------

bool libMHmu_gt_MapMechanic10SecondCountdownTimerExpires_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Actions

    if (!runActions) {

        return true;

    }



    SoundPlayForPlayer(SoundLink("UI_Game_Payload_Countdown", -1), c_maxPlayers, PlayerGroupAll(), 100.0, 0.0);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libMHmu_gt_MapMechanic10SecondCountdownTimerExpires_Init () {

    libMHmu_gt_MapMechanic10SecondCountdownTimerExpires = TriggerCreate("libMHmu_gt_MapMechanic10SecondCountdownTimerExpires_Func");

    TriggerAddEventTimer(libMHmu_gt_MapMechanic10SecondCountdownTimerExpires, libMHmu_gv_hanamuraMM10secondcountdownTimer);

}



//--------------------------------------------------------------------------------------------------

// Trigger: Henchmen - Create Vision Units

//--------------------------------------------------------------------------------------------------

bool libMHmu_gt_HenchmenCreateVisionUnits_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!(((libGame_gf_JungleCampSpawnedIndex() == 6) || (libGame_gf_JungleCampSpawnedIndex() == 5)))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    UnitCreate(1, "ReconCampVisionUnit", c_unitCreateIgnorePlacement, 0, libMapM_gv_jungleCreepCamps[libGame_gf_JungleCampSpawnedIndex()].lv_mapDataCampCaptainSpawnPoint, PointGetFacing(libMapM_gv_jungleCreepCamps[libGame_gf_JungleCampSpawnedIndex()].lv_mapDataCampCaptainSpawnPoint), null);

    libMHmu_gv_mercCamp_VisionUnit[libGame_gf_JungleCampSpawnedIndex()] = UnitLastCreated();

    if ((UnitIsValid(libMHmu_gv_mercCamp_VisionUnit[5]) == true) && (UnitIsValid(libMHmu_gv_mercCamp_VisionUnit[6]) == true)) {

        TriggerEnable(TriggerGetCurrent(), false);

    }



    return true;

}



//--------------------------------------------------------------------------------------------------

void libMHmu_gt_HenchmenCreateVisionUnits_Init () {

    libMHmu_gt_HenchmenCreateVisionUnits = TriggerCreate("libMHmu_gt_HenchmenCreateVisionUnits_Func");

    libGame_gf_JungleCampSpawned(libMHmu_gt_HenchmenCreateVisionUnits);

}



//--------------------------------------------------------------------------------------------------

// Trigger: Recon Camp Taken

//--------------------------------------------------------------------------------------------------

bool libMHmu_gt_ReconCampTaken_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_campIndex;

    int lv_rewardPlayer;

    int lv_rewardTeam;

    int lv_rewardCpuPlayer;

    point lv_captainSpawn;

    unitgroup lv_heroesOnPoint;

    bool[libCore_gv_bALMaxPlayers + 1] lv_isPlayerOnPoint;

    unit lv_heroUnit;

    int lv_player;



    // Automatic Variable Declarations

    unitgroup auto47101982_g;

    int auto47101982_u;

    const int auto4F86E8E4_ae = libCore_gv_bALMaxPlayers;

    const int auto4F86E8E4_ai = 1;



    // Variable Initialization

    lv_campIndex = libGame_gf_MercCampRewardGrantedCampIndex();

    lv_rewardPlayer = libGame_gf_MercCampRewardGrantedPlayer();

    lv_rewardTeam = libGame_gf_TeamNumberOfPlayer(lv_rewardPlayer);

    lv_rewardCpuPlayer = libGame_gf_ComputerPlayerInTeam(lv_rewardTeam);

    lv_captainSpawn = libMapM_gv_jungleCreepCamps[lv_campIndex].lv_mapDataCampCaptainSpawnPoint;

    lv_heroesOnPoint = UnitGroupEmpty();



    // Actions

    if (!runActions) {

        return true;

    }



    if ((libGame_gf_MercCampRewardGrantedCampIndex() == 5)) {

        UnitSetTokenCount(libGame_gv_teams[lv_rewardTeam].lv_core, "AIMapTokenMapControlMercenaryCampVisionTop", 1.0, libGame_gv_teams[lv_rewardTeam].lv_core);

        UnitSetTokenCount(libGame_gv_teams[libGame_gf_EnemyTeam(lv_rewardTeam)].lv_core, "AIMapTokenMapControlMercenaryCampVisionTop", 0.0, libGame_gv_teams[lv_rewardTeam].lv_core);

    }



    if ((libGame_gf_MercCampRewardGrantedCampIndex() == 6)) {

        UnitSetTokenCount(libGame_gv_teams[lv_rewardTeam].lv_core, "AIMapTokenMapControlMercenaryCampVisionBottom", 1.0, libGame_gv_teams[lv_rewardTeam].lv_core);

        UnitSetTokenCount(libGame_gv_teams[libGame_gf_EnemyTeam(lv_rewardTeam)].lv_core, "AIMapTokenMapControlMercenaryCampVisionBottom", 0.0, libGame_gv_teams[lv_rewardTeam].lv_core);

    }



    if (((libGame_gf_MercCampRewardGrantedCampIndex() == 5) || (libGame_gf_MercCampRewardGrantedCampIndex() == 6))) {

        UnitRemove(libMHmu_gv_mercCamp_VisionUnit[lv_campIndex]);

        UnitCreate(1, "ReconCampVisionUnit", c_unitCreateIgnorePlacement, lv_rewardCpuPlayer, lv_captainSpawn, PointGetFacing(lv_captainSpawn), null);

        libMHmu_gv_mercCamp_VisionUnit[lv_campIndex] = UnitLastCreated();

        UnitCreateEffectUnit(UnitLastCreated(), "WatchtowerRevealDummy", UnitLastCreated());

        libMHmu_gv_mercCamp_TeamOwner[lv_campIndex] = lv_rewardTeam;

        libMHmu_gf_HenchmenCustomRespawnCreepsForCamp(lv_campIndex, lv_rewardCpuPlayer);

        lv_heroesOnPoint = UnitGroupAlliance(lv_rewardCpuPlayer, c_unitAllianceAlly, RegionCircle(lv_captainSpawn, libMapM_gv_bALJungleCampCaptureRadius), UnitFilter((1 << c_targetFilterHeroic), 0, 0, 0), 0);

        auto47101982_g = lv_heroesOnPoint;

        auto47101982_u = UnitGroupCount(auto47101982_g, c_unitCountAll);

        for (;; auto47101982_u -= 1) {

            lv_heroUnit = UnitGroupUnitFromEnd(auto47101982_g, auto47101982_u);

            if (lv_heroUnit == null) { break; }

            if (((UnitFilterMatch(lv_heroUnit, UnitGetOwner(lv_heroUnit), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)) | (1 << (c_targetFilterBenign - 32)))) == true) || (UnitHasBehavior2(lv_heroUnit, "CapturePointAllowed") == true)) && ((UnitBehaviorCount(lv_heroUnit, "UltimateEvolutionBuff") == 1) || (UnitBehaviorCount(lv_heroUnit, "CapturePointAllowed") == 1) || (UnitTestState(lv_heroUnit, c_unitStateHallucination) == false))) {

                lv_isPlayerOnPoint[UnitGetOwner(lv_heroUnit)] = true;

            }



        }

        lv_player = 1;

        for ( ; ( (auto4F86E8E4_ai >= 0 && lv_player <= auto4F86E8E4_ae) || (auto4F86E8E4_ai < 0 && lv_player >= auto4F86E8E4_ae) ) ; lv_player += auto4F86E8E4_ai ) {

            if ((lv_isPlayerOnPoint[lv_player] == true)) {

                libGame_gv_scoreValues[lv_player].lv_watchTowersCaptured += 1;

            }



        }

    }



    return true;

}



//--------------------------------------------------------------------------------------------------

void libMHmu_gt_ReconCampTaken_Init () {

    libMHmu_gt_ReconCampTaken = TriggerCreate("libMHmu_gt_ReconCampTaken_Func");

    libGame_gf_MercCampRewardGranted(libMHmu_gt_ReconCampTaken);

}



//--------------------------------------------------------------------------------------------------

// Trigger: Initialize Minion Data

//--------------------------------------------------------------------------------------------------

bool libMHmu_gt_InitializeMinionData_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_composition;

    int lv_group;



    // Automatic Variable Declarations

    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_sYSCustomMinionsEnabled == false))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    lv_composition = (libCore_ge_MinionWaveCompositionsTypes_Standard);

    lv_group = 0;

    libCore_gv_dataMinionWaveCompositions[lv_composition].lv_name = StringExternal("Param/Value/lib_MHmu_9D807203");

    libCore_gv_dataMinionWaveCompositions[lv_composition].lv_enabled = true;

    lv_group += 1;

    libCore_gv_dataMinionWaveCompositions[lv_composition].lv_groupMinionType[lv_group] = libCore_ge_MinionTypes_Footmen;

    libCore_gv_dataMinionWaveCompositions[lv_composition].lv_groupMinionCount[lv_group] = 3;

    lv_group += 1;

    libCore_gv_dataMinionWaveCompositions[lv_composition].lv_groupMinionType[lv_group] = libCore_ge_MinionTypes_Wizard;

    libCore_gv_dataMinionWaveCompositions[lv_composition].lv_groupMinionCount[lv_group] = 1;

    lv_group += 1;

    libCore_gv_dataMinionWaveCompositions[lv_composition].lv_groupMinionType[lv_group] = libCore_ge_MinionTypes_Ranged;

    libCore_gv_dataMinionWaveCompositions[lv_composition].lv_groupMinionCount[lv_group] = 3;

    lv_group += 1;

    libCore_gv_dataMinionWaveCompositions[lv_composition].lv_groupMinionType[lv_group] = libCore_ge_MinionTypes_Catapult;

    libCore_gv_dataMinionWaveCompositions[lv_composition].lv_groupMinionCount[lv_group] = 1;

    libCore_gv_dataMinionWaveCompositions[lv_composition].lv_numberOfGroups = lv_group;

    return true;

}



//--------------------------------------------------------------------------------------------------

void libMHmu_gt_InitializeMinionData_Init () {

    libMHmu_gt_InitializeMinionData = TriggerCreate("libMHmu_gt_InitializeMinionData_Func");

}



//--------------------------------------------------------------------------------------------------

// Trigger: Initialize Minion Scaling Data

//--------------------------------------------------------------------------------------------------

bool libMHmu_gt_InitializeMinionScalingData_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_sYSCustomMinionsEnabled == false))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libCore_gf_DataInitializeScalingDataForMinion("FootmanMinion", libCore_ge_MinionTypes_Footmen);

    libCore_gf_DataInitializeScalingDataForMinion("WizardMinion", libCore_ge_MinionTypes_Wizard);

    libCore_gf_DataInitializeScalingDataForMinion("RangedMinion", libCore_ge_MinionTypes_Ranged);

    libCore_gf_DataInitializeScalingDataForMinion("CatapultMinion", libCore_ge_MinionTypes_CustomCatapult1);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libMHmu_gt_InitializeMinionScalingData_Init () {

    libMHmu_gt_InitializeMinionScalingData = TriggerCreate("libMHmu_gt_InitializeMinionScalingData_Func");

}



//--------------------------------------------------------------------------------------------------

// Trigger: Payload Target On

//--------------------------------------------------------------------------------------------------

bool libMHmu_gt_PayloadTargetOn_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_team;



    // Automatic Variable Declarations

    unitgroup autoF299F3A1_g;

    int autoF299F3A1_u;

    unit autoF299F3A1_var;



    // Variable Initialization

    lv_team = libGame_gf_TeamNumberOfPlayer(EventPlayer());



    // Actions

    if (!runActions) {

        return true;

    }



    autoF299F3A1_g = libGame_gv_players[EventPlayer()].lv_heroUnitGroup;

    autoF299F3A1_u = UnitGroupCount(autoF299F3A1_g, c_unitCountAll);

    for (;; autoF299F3A1_u -= 1) {

        autoF299F3A1_var = UnitGroupUnitFromEnd(autoF299F3A1_g, autoF299F3A1_u);

        if (autoF299F3A1_var == null) { break; }

        if ((UnitIsSelected(autoF299F3A1_var, EventPlayer()) == true) && (UnitGetType(autoF299F3A1_var) != "HeroLostVikingsController")) {

            libMHmu_gv_heroInTargetMode[EventPlayer()] = autoF299F3A1_var;

            break;

        }



    }

    if ((libNPLD_gv_neutralPayload.lv_unit != null)) {

        UnitCreateEffectUnit(libMHmu_gv_heroInTargetMode[EventPlayer()], "PayloadTurretDummyEffectToMakePlaceholderImage", libNPLD_gv_neutralPayload.lv_unit);

    }



    return true;

}



//--------------------------------------------------------------------------------------------------

void libMHmu_gt_PayloadTargetOn_Init () {

    libMHmu_gt_PayloadTargetOn = TriggerCreate("libMHmu_gt_PayloadTargetOn_Func");

    TriggerAddEventTargetModeUpdate(libMHmu_gt_PayloadTargetOn, c_playerAny, AbilityCommand("MapMechanicAbilityTarget", 0), c_targetModeStateOn);

}



//--------------------------------------------------------------------------------------------------

// Trigger: Payload Target Off

//--------------------------------------------------------------------------------------------------

bool libMHmu_gt_PayloadTargetOff_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    unitgroup auto52F595B8_g;

    int auto52F595B8_u;

    unit auto52F595B8_var;



    // Actions

    if (!runActions) {

        return true;

    }



    auto52F595B8_g = libGame_gv_players[EventPlayer()].lv_heroUnitGroup;

    auto52F595B8_u = UnitGroupCount(auto52F595B8_g, c_unitCountAll);

    for (;; auto52F595B8_u -= 1) {

        auto52F595B8_var = UnitGroupUnitFromEnd(auto52F595B8_g, auto52F595B8_u);

        if (auto52F595B8_var == null) { break; }

        UnitCreateEffectUnit(auto52F595B8_var, "PayloadTurretDummyEffectToDestroyPlaceholderImage", auto52F595B8_var);

    }

    libMHmu_gv_heroInTargetMode[EventPlayer()] = null;

    return true;

}



//--------------------------------------------------------------------------------------------------

void libMHmu_gt_PayloadTargetOff_Init () {

    libMHmu_gt_PayloadTargetOff = TriggerCreate("libMHmu_gt_PayloadTargetOff_Func");

    TriggerAddEventTargetModeUpdate(libMHmu_gt_PayloadTargetOff, c_playerAny, AbilityCommand("MapMechanicAbilityTarget", 0), c_targetModeStateOff);

}



//--------------------------------------------------------------------------------------------------

// Trigger: Payload Reaches Destination

//--------------------------------------------------------------------------------------------------

bool libMHmu_gt_PayloadReachesDestination_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unitgroup lv_bannerUnitGroup;

    int lv_bannerPlayerID;

    unit lv_bannerSconce;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_bannerUnitGroup = UnitGroupEmpty();



    // Actions

    if (!runActions) {

        return true;

    }



    if ((libNPLD_gf_UnitStopsOccupyingVehicleVehicle() == 1)) {

        libMHmu_gf_PayloadsPathCompletedOrder();

    }

    else {

        libMHmu_gf_PayloadsPathCompletedChaos();

    }

    libMHmu_gf_ElevatorAttempttoLowerMonitor();

    libMHmu_gf_DestroyDestinationIndicator(libGame_gv_teamOrderIndex_C);

    libMHmu_gf_DestroyDestinationIndicator(libGame_gv_teamChaosIndex_C);

    RemoveUnitOfInterest(libNPLD_gv_neutralPayload.lv_unit, "EscortPayload", libNtve_ge_GoalTeam_Both);

    TimerStart(libMHmu_gv_hanamura.lv_mapMechanic_ObjectivePreviewTimer, (libMHmu_gv_mapMechanic_CooldownTimer_Duration - libMHmu_gv_mapMechanic_WarningTimer_Duration), false, c_timeGame);

    UnitCreateEffectUnit(libNPLD_gv_neutralPayload.lv_unit, "RegenGlobePickupSearchSet", libNPLD_gv_neutralPayload.lv_unit);

    lv_bannerUnitGroup = UnitGroupAlliance(UnitGetOwner(libNPLD_gv_neutralPayload.lv_unit), c_unitAllianceAlly, RegionCircle(UnitGetPosition(libNPLD_gv_neutralPayload.lv_unit), 12.0), UnitFilter((1 << c_targetFilterHeroic), 0, (1 << c_targetFilterNeutral) | (1 << c_targetFilterEnemy), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)) | (1 << (c_targetFilterSummoned - 32))), 0);

    lv_bannerPlayerID = UnitGetOwner(UnitGroupRandomUnit(lv_bannerUnitGroup, c_unitCountAlive));

    lv_bannerSconce = UnitGroupClosestToPoint(UnitGroup("LootBannerSconce", c_playerAny, RegionCircle(UnitGetPosition(libNPLD_gv_neutralPayload.lv_unit), 12.0), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0), UnitGetPosition(libNPLD_gv_neutralPayload.lv_unit));

    if ((lv_bannerPlayerID >= 1) && (lv_bannerPlayerID <= 10) && (lv_bannerSconce != null) && (UnitIsValid(lv_bannerSconce) == true)) {

        libGame_gf_DropLootBannerinSconce(lv_bannerSconce, libGame_gv_players[lv_bannerPlayerID].lv_lootContent.lv_loot_Banner.lv_bannerID, lv_bannerPlayerID, true);

    }



    libNPLD_gf_PayloadPathsDestroyActivePaths();

    libSond_gf_SoundtrackUpdateMapSoundtrackIndex();

    libSond_gf_SoundtrackPlayMapSoundtrackAsDefaultSoundtrackForAllPlayers();

    Wait(1.0, c_timeGame);

    DialogControlSetVisible(libNPLD_gv_hanamura.lv_attackingStructureFrame[libNPLD_gf_UnitStopsOccupyingVehicleVehicle()], PlayerGroupAll(), true);

    DialogControlSetVisible(libNPLD_gv_hanamura.lv_payloadPanel_ActivePayloadStatus, PlayerGroupAll(), false);

    Wait(1.0, c_timeGame);

    libMHmu_gf_MakePayloadAttack(libNPLD_gf_UnitStopsOccupyingVehicleVehicle());

    Wait(1.0, c_timeGame);

    UnitKill(libNPLD_gv_neutralPayload.lv_unit);

    libNPLD_gf_SetNewPayloadPathForTeam(libNPLD_gf_UnitStopsOccupyingVehicleVehicle());

    Wait(1.0, c_timeGame);

    libNPLD_gv_neutralPayload.lv_completedReward = true;

    return true;

}



//--------------------------------------------------------------------------------------------------

void libMHmu_gt_PayloadReachesDestination_Init () {

    libMHmu_gt_PayloadReachesDestination = TriggerCreate("libMHmu_gt_PayloadReachesDestination_Func");

    libNPLD_gf_PayloadReachedDestination(libMHmu_gt_PayloadReachesDestination);

}



//--------------------------------------------------------------------------------------------------

// Trigger: Keep Or Fort Gets Taken Over

//--------------------------------------------------------------------------------------------------

bool libMHmu_gt_KeepOrFortGetsTakenOver_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_fortBuilding;

    unit lv_bigRag;

    unit lv_noUnit;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_fortBuilding = EventPlayerEffectUsedUnit(c_effectUnitTarget);



    // Actions

    if (!runActions) {

        return true;

    }



    while (!(((UnitIsAlive(lv_fortBuilding) == false) || (UnitHasBehavior2(lv_fortBuilding, "RagnarosMoltenCoreStructureStasis") == true)))) {

        Wait(0.0625, c_timeGame);

    }

    if ((UnitIsAlive(lv_fortBuilding) == false)) {

        return true;

    }



    lv_bigRag = UnitGroupUnit(libGame_gv_players[EventPlayerEffectUsedUnitOwner(c_effectPlayerCaster)].lv_cameraPlayerUnitGroupToFocusOn, 1);

    libCore_gf_StoreUnitForUnit(lv_fortBuilding, 99, lv_bigRag);

    libCore_gf_StoreUnitForUnit(lv_bigRag, 99, lv_fortBuilding);

    while (!((UnitHasBehavior2(lv_fortBuilding, "RagnarosMoltenCoreStructureStasis") == false))) {

        Wait(0.0625, c_timeGame);

    }

    libCore_gf_StoreUnitForUnit(lv_fortBuilding, 99, lv_noUnit);

    libCore_gf_StoreUnitForUnit(lv_bigRag, 99, lv_noUnit);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libMHmu_gt_KeepOrFortGetsTakenOver_Init () {

    libMHmu_gt_KeepOrFortGetsTakenOver = TriggerCreate("libMHmu_gt_KeepOrFortGetsTakenOver_Func");

    TriggerAddEventPlayerEffectUsed(libMHmu_gt_KeepOrFortGetsTakenOver, c_playerAny, "RagnarosMoltenCoreSmokeScreenApplyBehavior");

}



//--------------------------------------------------------------------------------------------------

// Trigger: Payload Attack Launch

//--------------------------------------------------------------------------------------------------

bool libMHmu_gt_PayloadAttackLaunch_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Actions

    if (!runActions) {

        return true;

    }



    libMHmu_gv_missileInFlightCount += 1;

    return true;

}



//--------------------------------------------------------------------------------------------------

void libMHmu_gt_PayloadAttackLaunch_Init () {

    libMHmu_gt_PayloadAttackLaunch = TriggerCreate("libMHmu_gt_PayloadAttackLaunch_Func");

    TriggerAddEventPlayerEffectUsed(libMHmu_gt_PayloadAttackLaunch, 11, "Payload_AttackLM");

    TriggerAddEventPlayerEffectUsed(libMHmu_gt_PayloadAttackLaunch, 12, "Payload_AttackLM");

}



//--------------------------------------------------------------------------------------------------

// Trigger: Payload Attack Impact

//--------------------------------------------------------------------------------------------------

bool libMHmu_gt_PayloadAttackImpact_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Actions

    if (!runActions) {

        return true;

    }



    libMHmu_gv_missileInFlightCount -= 1;

    return true;

}



//--------------------------------------------------------------------------------------------------

void libMHmu_gt_PayloadAttackImpact_Init () {

    libMHmu_gt_PayloadAttackImpact = TriggerCreate("libMHmu_gt_PayloadAttackImpact_Func");

    TriggerAddEventPlayerEffectUsed(libMHmu_gt_PayloadAttackImpact, 11, "Payload_AttackDamage");

    TriggerAddEventPlayerEffectUsed(libMHmu_gt_PayloadAttackImpact, 12, "Payload_AttackDamage");

}



//--------------------------------------------------------------------------------------------------

// Trigger: Elevator - Add Unpathable Location At Start

//--------------------------------------------------------------------------------------------------

bool libMHmu_gt_ElevatorAddUnpathableLocationAtStart_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Actions

    if (!runActions) {

        return true;

    }



    libMHmu_gf_ElevatorAddRemoveUnpathableUnit(true);

    libMHmu_gv_elevator_WaitingToLower = true;

    return true;

}



//--------------------------------------------------------------------------------------------------

void libMHmu_gt_ElevatorAddUnpathableLocationAtStart_Init () {

    libMHmu_gt_ElevatorAddUnpathableLocationAtStart = TriggerCreate("libMHmu_gt_ElevatorAddUnpathableLocationAtStart_Func");

    TriggerAddEventTimer(libMHmu_gt_ElevatorAddUnpathableLocationAtStart, libGame_gv_openTheGatesTimer);

}



//--------------------------------------------------------------------------------------------------

// Trigger: Elevator - Start Initial Timer

//--------------------------------------------------------------------------------------------------

bool libMHmu_gt_ElevatorStartInitialTimer_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Actions

    if (!runActions) {

        return true;

    }



    libMHmu_gf_ElevatorAddRemoveUnpathableUnit(true);

    TimerStart(libMHmu_gv_elevator.lv_elevatorInitialRaiseTimer, (libMHmu_gv_mapMechanic_CooldownTimer_Duration - 8.0), false, c_timeGame);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libMHmu_gt_ElevatorStartInitialTimer_Init () {

    libMHmu_gt_ElevatorStartInitialTimer = TriggerCreate("libMHmu_gt_ElevatorStartInitialTimer_Func");

    TriggerAddEventTimer(libMHmu_gt_ElevatorStartInitialTimer, libGame_gv_openTheGatesTimer);

}



//--------------------------------------------------------------------------------------------------

// Trigger: Elevator Initial Timer Expires

//--------------------------------------------------------------------------------------------------

bool libMHmu_gt_ElevatorInitialTimerExpires_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Actions

    if (!runActions) {

        return true;

    }



    ActorSend(ActorFromDoodad(libMHmu_gv_elevator_Doodad), "Signal Up");

    return true;

}



//--------------------------------------------------------------------------------------------------

void libMHmu_gt_ElevatorInitialTimerExpires_Init () {

    libMHmu_gt_ElevatorInitialTimerExpires = TriggerCreate("libMHmu_gt_ElevatorInitialTimerExpires_Func");

    TriggerAddEventTimer(libMHmu_gt_ElevatorInitialTimerExpires, libMHmu_gv_elevator.lv_elevatorInitialRaiseTimer);

}



//--------------------------------------------------------------------------------------------------

// Trigger: Elevator Raise Timer Expires

//--------------------------------------------------------------------------------------------------

bool libMHmu_gt_ElevatorRaiseTimerExpires_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Actions

    if (!runActions) {

        return true;

    }



    if ((libMHmu_gv_elevator.lv_elevatorWasLowered == true)) {

        ActorSend(ActorFromDoodad(libMHmu_gv_elevator_Doodad), "Signal Up");

        PointSet(libNPLD_gv_neutralPayload.lv_pathWaypoints_StartLocation, libMHmu_gv_elevator_Point);

    }



    return true;

}



//--------------------------------------------------------------------------------------------------

void libMHmu_gt_ElevatorRaiseTimerExpires_Init () {

    libMHmu_gt_ElevatorRaiseTimerExpires = TriggerCreate("libMHmu_gt_ElevatorRaiseTimerExpires_Func");

    TriggerAddEventTimer(libMHmu_gt_ElevatorRaiseTimerExpires, libMHmu_gv_elevator.lv_elevatorRaiseTimer);

}



//--------------------------------------------------------------------------------------------------

// Trigger: Elevator - Forced Lower

//--------------------------------------------------------------------------------------------------

bool libMHmu_gt_ElevatorForcedLower_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Actions

    if (!runActions) {

        return true;

    }



    libMHmu_gv_elevator_WaitingToLower = false;

    return true;

}



//--------------------------------------------------------------------------------------------------

void libMHmu_gt_ElevatorForcedLower_Init () {

    libMHmu_gt_ElevatorForcedLower = TriggerCreate("libMHmu_gt_ElevatorForcedLower_Func");

    TriggerAddEventTimer(libMHmu_gt_ElevatorForcedLower, libMHmu_gv_elevator_Forced_Lower_Timer);

}



//--------------------------------------------------------------------------------------------------

// Trigger: EOM Initialize Pusher Behaviors

//--------------------------------------------------------------------------------------------------

bool libMHmu_gt_EOMInitializePusherBehaviors_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_iteratorUnit;

    int lv_iterator;



    // Automatic Variable Declarations

    int auto3D2683EB_ae;

    unitgroup autoA14C2C83_g;

    int autoA14C2C83_u;



    // Variable Initialization



    // Actions

    if (!runActions) {

        return true;

    }



    auto3D2683EB_ae = libCore_gv_bALMaxPlayers;

    lv_iterator = 1;

    for ( ; lv_iterator <= auto3D2683EB_ae ; lv_iterator += 1 ) {

        autoA14C2C83_g = libGame_gv_players[lv_iterator].lv_heroUnitGroup;

        autoA14C2C83_u = UnitGroupCount(autoA14C2C83_g, c_unitCountAll);

        for (;; autoA14C2C83_u -= 1) {

            lv_iteratorUnit = UnitGroupUnitFromEnd(autoA14C2C83_g, autoA14C2C83_u);

            if (lv_iteratorUnit == null) { break; }

            UnitCreateEffectUnit(lv_iteratorUnit, "ApplyAllyPayloadPusherBehavior", lv_iteratorUnit);

        }

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libMHmu_gt_EOMInitializePusherBehaviors_Init () {

    libMHmu_gt_EOMInitializePusherBehaviors = TriggerCreate("libMHmu_gt_EOMInitializePusherBehaviors_Func");

    TriggerAddEventTimer(libMHmu_gt_EOMInitializePusherBehaviors, libGame_gv_openTheGatesTimer);

}



//--------------------------------------------------------------------------------------------------

// Trigger: EOM Pusher Added

//--------------------------------------------------------------------------------------------------

bool libMHmu_gt_EOMPusherAdded_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_pushingPlayer;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_pushingPlayer = EventPlayer();



    // Conditions

    if (testConds) {

        if (!((lv_pushingPlayer <= libCore_gv_bALMaxPlayers))) {

            return false;

        }



        if (!((lv_pushingPlayer > 0))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    TimerPause(libMHmu_gv_eOMPusherTimer[lv_pushingPlayer], false);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libMHmu_gt_EOMPusherAdded_Init () {

    libMHmu_gt_EOMPusherAdded = TriggerCreate("libMHmu_gt_EOMPusherAdded_Func");

    TriggerAddEventUnitBehaviorChange(libMHmu_gt_EOMPusherAdded, null, "AllyPayloadPusherBehavior", c_unitBehaviorChangeActivate);

}



//--------------------------------------------------------------------------------------------------

// Trigger: EOM Pusher Removed

//--------------------------------------------------------------------------------------------------

bool libMHmu_gt_EOMPusherRemoved_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_pushingPlayer;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_pushingPlayer = EventPlayer();



    // Conditions

    if (testConds) {

        if (!((lv_pushingPlayer <= libCore_gv_bALMaxPlayers))) {

            return false;

        }



        if (!((lv_pushingPlayer > 0))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    TimerPause(libMHmu_gv_eOMPusherTimer[lv_pushingPlayer], true);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libMHmu_gt_EOMPusherRemoved_Init () {

    libMHmu_gt_EOMPusherRemoved = TriggerCreate("libMHmu_gt_EOMPusherRemoved_Func");

    TriggerAddEventUnitBehaviorChange(libMHmu_gt_EOMPusherRemoved, null, "AllyPayloadPusherBehavior", c_unitBehaviorChangeDeactivate);

}



//--------------------------------------------------------------------------------------------------

// Trigger: EOM Report Pushing Score

//--------------------------------------------------------------------------------------------------

bool libMHmu_gt_EOMReportPushingScore_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_iterator;



    // Automatic Variable Declarations

    int auto9692B77F_ae;



    // Variable Initialization



    // Actions

    if (!runActions) {

        return true;

    }



    auto9692B77F_ae = libCore_gv_bALMaxPlayers;

    lv_iterator = 1;

    for ( ; lv_iterator <= auto9692B77F_ae ; lv_iterator += 1 ) {

        libGame_gf_ScoreValuesReportRealValueAndLog(lv_iterator, "TimeOnPayload", TimerGetDuration(libMHmu_gv_eOMPusherTimer[lv_iterator]));

        libGame_gf_SendMapSpecificAwardEvent(lv_iterator, TimerGetDuration(libMHmu_gv_eOMPusherTimer[lv_iterator]), false);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libMHmu_gt_EOMReportPushingScore_Init () {

    libMHmu_gt_EOMReportPushingScore = TriggerCreate("libMHmu_gt_EOMReportPushingScore_Func");

    libGame_gf_GameOverEvent(libMHmu_gt_EOMReportPushingScore);

}



//--------------------------------------------------------------------------------------------------

// Trigger: EventStart

//--------------------------------------------------------------------------------------------------

bool libMHmu_gt_EventStart_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    unitgroup auto3D243644_g;

    int auto3D243644_u;

    unit auto3D243644_var;



    // Conditions

    if (testConds) {

        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((TimerGetRemaining(libGame_gv_openTheGatesTimer) > 0.0)) {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_MHmu_0C0500FD"), true);

        return true;

    }



    TimerStart(libMHmu_gv_hanamura.lv_mapMechanic_ObjectivePreviewTimer, 0.0625, false, c_timeGame);

    Wait(0.125, c_timeGame);

    TimerStart(libMHmu_gv_hanamura.lv_mapMechanic_ObjectivePreviewDelay, 8.125, false, c_timeGame);

    if ((TimerGetRemaining(libMHmu_gv_elevator.lv_elevatorInitialRaiseTimer) > 0.125)) {

        TimerStart(libMHmu_gv_elevator.lv_elevatorInitialRaiseTimer, 0.125, false, c_timeGame);

    }

    else {

        TimerStart(libMHmu_gv_elevator.lv_elevatorRaiseTimer, 0.125, false, c_timeGame);

    }

    if ((TimerGetRemaining(libMHmu_gv_hanamuraMM10secondcountdownTimer) > 0.0)) {

        libNtve_gf_StopTimer(libMHmu_gv_hanamuraMM10secondcountdownTimer);

        SoundPlayForPlayer(SoundLink("UI_Game_Payload_Countdown", -1), c_maxPlayers, PlayerGroupAll(), 100.0, 2.0);

    }



    ActorSend(libMHmu_gv_hanamura.lv_hanamuraActorOnlyGates[0], "Signal PlayBuild");

    ActorSend(libMHmu_gv_hanamura.lv_hanamuraActorOnlyGates[1], "Signal PlayBuild");

    ActorSend(libMHmu_gv_hanamura.lv_hanamuraActorOnlyGates[2], "Signal PlayBuild");

    ActorSend(libMHmu_gv_hanamura.lv_hanamuraActorOnlyGates[3], "Signal PlayBuild");

    TriggerDebugOutput(1, StringExternal("Param/Value/lib_MHmu_39FAF074"), true);

    libNtve_gf_StopTimer(libMHmu_gv_elevator_Forced_Lower_Timer);

    libMHmu_gv_elevator_WaitingToLower = false;

    ActorSend(ActorFromDoodad(libMHmu_gv_elevator_Doodad), "AnimBracketClear Morph Instant");

    libMHmu_gf_ElevatorAddRemoveUnpathableUnit(true);

    auto3D243644_g = UnitGroup(null, c_playerAny, libMHmu_gv_elevator_Region, libCore_gv_filtersHeroic, 0);

    auto3D243644_u = UnitGroupCount(auto3D243644_g, c_unitCountAll);

    for (;; auto3D243644_u -= 1) {

        auto3D243644_var = UnitGroupUnitFromEnd(auto3D243644_g, auto3D243644_u);

        if (auto3D243644_var == null) { break; }

        UnitCreateEffectUnit(auto3D243644_var, "HeroGenericMissileInterruptLaunchMissile", auto3D243644_var);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libMHmu_gt_EventStart_Init () {

    libMHmu_gt_EventStart = TriggerCreate("libMHmu_gt_EventStart_Func");

    TriggerAddEventChatMessage(libMHmu_gt_EventStart, c_playerAny, "eventstart", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: ppath

//--------------------------------------------------------------------------------------------------

bool libMHmu_gt_ppath_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_orderPath;

    int lv_chaosPath;

    string lv_inputPathOrder;

    string lv_inputPathChaos;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_inputPathOrder = "";

    lv_inputPathChaos = "";



    // Conditions

    if (testConds) {

        if (!((true))) {

            return false;

        }



        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    lv_inputPathOrder = StringWord(EventChatMessage(false), 2);

    lv_inputPathChaos = StringWord(EventChatMessage(false), 3);

    lv_orderPath = libMHmu_gf_ppathGetPathID(lv_inputPathOrder);

    lv_chaosPath = libMHmu_gf_ppathGetPathID(lv_inputPathChaos);

    if ((lv_orderPath == 0)) {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_MHmu_01E86D63"), true);

        return true;

    }



    if ((lv_chaosPath == 0)) {

        lv_chaosPath = lv_orderPath;

    }



    if (((UnitIsValid(libNPLD_gv_neutralPayload.lv_warningUnit) == true) || (UnitIsValid(libNPLD_gv_neutralPayload.lv_unit) == true) || (TimerGetRemaining(libGame_gv_openTheGatesTimer) > 0.0))) {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_MHmu_713D7A71"), true);

        return true;

    }



    libNPLD_gv_neutralPayload.lv_pathIndex_Team[libGame_gv_teamOrderIndex_C] = lv_orderPath;

    libNPLD_gv_neutralPayload.lv_pathIndex_Team[libGame_gv_teamChaosIndex_C] = lv_chaosPath;

    TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_MHmu_227B2267"), true);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libMHmu_gt_ppath_Init () {

    libMHmu_gt_ppath = TriggerCreate("libMHmu_gt_ppath_Func");

    TriggerAddEventChatMessage(libMHmu_gt_ppath, c_playerAny, "ppath", false);

}



void libMHmu_InitTriggers () {

    libMHmu_gt_HanamuraCoreBarrageProc_Init();

    libMHmu_gt_MapInitialization_Init();

    libMHmu_gt_MapMechanicInitialized_Init();

    libMHmu_gt_OpenTheGatesTimerExpires_Init();

    libMHmu_gt_MapMechanicTimerExpires_Init();

    libMHmu_gt_MapMechanicWarningExpires_Init();

    libMHmu_gt_MapMechanic10SecondCountdownTimerExpires_Init();

    libMHmu_gt_HenchmenCreateVisionUnits_Init();

    libMHmu_gt_ReconCampTaken_Init();

    libMHmu_gt_InitializeMinionData_Init();

    libMHmu_gt_InitializeMinionScalingData_Init();

    libMHmu_gt_PayloadTargetOn_Init();

    libMHmu_gt_PayloadTargetOff_Init();

    libMHmu_gt_PayloadReachesDestination_Init();

    libMHmu_gt_KeepOrFortGetsTakenOver_Init();

    libMHmu_gt_PayloadAttackLaunch_Init();

    libMHmu_gt_PayloadAttackImpact_Init();

    libMHmu_gt_ElevatorAddUnpathableLocationAtStart_Init();

    libMHmu_gt_ElevatorStartInitialTimer_Init();

    libMHmu_gt_ElevatorInitialTimerExpires_Init();

    libMHmu_gt_ElevatorRaiseTimerExpires_Init();

    libMHmu_gt_ElevatorForcedLower_Init();

    libMHmu_gt_EOMInitializePusherBehaviors_Init();

    libMHmu_gt_EOMPusherAdded_Init();

    libMHmu_gt_EOMPusherRemoved_Init();

    libMHmu_gt_EOMReportPushingScore_Init();

    libMHmu_gt_EventStart_Init();

    libMHmu_gt_ppath_Init();

}



//--------------------------------------------------------------------------------------------------

// Library Initialization

//--------------------------------------------------------------------------------------------------

bool libMHmu_InitLib_completed = false;



void libMHmu_InitLib () {

    if (libMHmu_InitLib_completed) {

        return;

    }



    libMHmu_InitLib_completed = true;



    libMHmu_InitLibraries();

    libMHmu_InitVariables();

    libMHmu_InitTriggers();

}



include "LibNPLD"