include "TriggerLibs/NativeLib"

include "TriggerLibs/HeroesLib"

include "TriggerLibs/GameLib"

include "TriggerLibs/MapMechanicsLib"

include "TriggerLibs/AILib"

include "TriggerLibs/UILib"

include "TriggerLibs/SoundLib"

include "LibMLHH"

include "LibMSHD"



include "LibMSHE_h"



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

// Library: Infernal Shrines (Mod)

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

// External Library Initialization

void libMSHE_InitLibraries () {

    libNtve_InitVariables();

    libCore_InitVariables();

    libGame_InitVariables();

    libMapM_InitVariables();

    libAIAI_InitVariables();

    libUIUI_InitVariables();

    libSond_InitVariables();

    libMLHH_InitVariables();

    libMSHD_InitVariables();

}



// Variable Initialization

bool libMSHE_InitVariables_completed = false;



void libMSHE_InitVariables () {

    int init_i;

    int init_i1;



    if (libMSHE_InitVariables_completed) {

        return;

    }



    libMSHE_InitVariables_completed = true;



    libMSHE_gv_mMDiabloShrinesShrineTimerWarning = 15.0;

    libMSHE_gv_mMISShrineTimer = TimerCreate();

    libMSHE_gv_mMISBuffTimer = TimerCreate();

    libMSHE_gv_mMISShrineWarningTimer = TimerCreate();

    libMSHE_gv_mMISExperince = TimerCreate();

    libMSHE_gv_mMISCursedRefreshTimer = TimerCreate();

    libMSHE_gv_mMISLongWarningTimer = TimerCreate();

    libMSHE_gv_mMISMonsterGroup = PlayerGroupEmpty();

    libMSHE_gv_mMISCursedCreatures = UnitGroupEmpty();

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

        libMSHE_gv_mMISTextTag[init_i] = c_textTagNone;

    }

    libMSHE_gv_mMISInactiveShrines = UnitGroupEmpty();

    libMSHE_gv_mMISActiveShrines = UnitGroupEmpty();

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

        libMSHE_gv_mMISShrineGroups[init_i] = UnitGroupEmpty();

    }

    libMSHE_gv_mMISNumberofShrinesAllowed = 3;

    libMSHE_gv_mMISShrineGroup = PlayerGroupEmpty();

    libMSHE_gv_mMISParalyzeStorage = UnitGroupEmpty();

    libMSHE_gv_mMISObjectivePreviewTimer = TimerCreate();

    libMSHE_gv_mMISObjectivePreviewDelay_C = 30.0;

    libMSHE_gv_mMISShrineReminderDelay_C = 20;

    libMSHE_gv_mMISShrineReminderTimer = TimerCreate();

    libMSHE_gv_mMISShrineNotificationDelay_C = 44;

    libMSHE_gv_mMISShrineNotificationTimer = TimerCreate();

    libMSHE_gv_mMISPunisherSpawnTimer = TimerCreate();

    libMSHE_gv_mMISAffixTimer = TimerCreate();

    libMSHE_gv_mMISAffixTimerDuration = 60;

    libMSHE_gv_mMTowerPushPanel.lv_mainPanel = c_invalidDialogControlId;

    for (init_i1 = 0; init_i1 <= 2; init_i1 += 1) {

        libMSHE_gv_mMTowerPushPanel.lv_towerPushEnergyGlobePower[init_i1] = c_invalidDialogControlId;

    }

    libMSHE_gv_mMTowerPushPanel.lv_shrineWarningFrame = c_invalidDialogControlId;

    libMSHE_gv_mMTowerPushPanel.lv_shrineWarningInfoLabel = c_invalidDialogControlId;

    libMSHE_gv_mMTowerPushPanel.lv_shrineWarningTimerLabel = c_invalidDialogControlId;

    libMSHE_gv_mMTowerPushPanel.lv_shrineActiveFrame = c_invalidDialogControlId;

    libMSHE_gv_mMTowerPushPanel.lv_shrineActiveInfoLabel = c_invalidDialogControlId;

    libMSHE_gv_mMTowerPushPanel.lv_crystalMortarIcon = c_invalidDialogControlId;

    libMSHE_gv_mMTowerPushPanel.lv_crystalFrozenIcon = c_invalidDialogControlId;

    libMSHE_gv_mMTowerPushPanel.lv_crystalArcaneIcon = c_invalidDialogControlId;

    libMSHE_gv_mMTowerPushPanel.lv_reinforcementWarningFrame = c_invalidDialogControlId;

    libMSHE_gv_mMTowerPushPanel.lv_reinforcementWarningInfoLabel = c_invalidDialogControlId;

    libMSHE_gv_mMTowerPushPanel.lv_reinforcementWarningTimerLabel = c_invalidDialogControlId;

    libMSHE_gv_mMTowerPushPanel.lv_hauntedMinesSkullModeFrame = c_invalidDialogControlId;

    for (init_i1 = 0; init_i1 <= libCore_gv_bALMaxTeams; init_i1 += 1) {

        libMSHE_gv_mMTowerPushPanel.lv_hauntedMinesSkullModeSkullCounterLabel[init_i1] = c_invalidDialogControlId;

    }

    libMSHE_gv_mMTowerPushPanel.lv_punisherFrame = c_invalidDialogControlId;

    libMSHE_gv_mMTowerPushPanel.lv_punisherHealthBar = c_invalidDialogControlId;

    libMSHE_gv_mMTowerPushPanel.lv_punisherTimer = c_invalidDialogControlId;

    libMSHE_gv_mMTowerPushPanel.lv_punisherInfoLabel = c_invalidDialogControlId;

    libMSHE_gv_mMTowerPushPanel.lv_punisherArcaneAllyIcon = c_invalidDialogControlId;

    libMSHE_gv_mMTowerPushPanel.lv_punisherArcaneEnemyIcon = c_invalidDialogControlId;

    libMSHE_gv_mMTowerPushPanel.lv_punisherFrozenAllyIcon = c_invalidDialogControlId;

    libMSHE_gv_mMTowerPushPanel.lv_punisherFrozenEnemyIcon = c_invalidDialogControlId;

    libMSHE_gv_mMTowerPushPanel.lv_punisherMortarAllyIcon = c_invalidDialogControlId;

    libMSHE_gv_mMTowerPushPanel.lv_punisherMortarEnemyIcon = c_invalidDialogControlId;

}



// Presets

// Functions

void libMSHE_gf_MMISMapData (point lp_monsterShrine, unit lp_diabloShrineTop, unit lp_diabloShrineMiddle, unit lp_diabloShrineBottom, region lp_diabloShrineTopRegion, region lp_diabloShrineMiddleRegion, region lp_diabloShrineBottomRegion) {

    // Automatic Variable Declarations

    // Implementation

    libMSHE_gv_mMISShrines[1] = lp_diabloShrineTop;

    libMSHE_gv_mMISShrines[2] = lp_diabloShrineMiddle;

    libMSHE_gv_mMISShrines[3] = lp_diabloShrineBottom;

    libMSHE_gv_mMISRegions[1] = lp_diabloShrineTopRegion;

    libMSHE_gv_mMISRegions[2] = lp_diabloShrineMiddleRegion;

    libMSHE_gv_mMISRegions[3] = lp_diabloShrineBottomRegion;

    UnitGroupAdd(libMSHE_gv_mMISShrineGroups[1], libMSHE_gv_mMISShrines[1]);

    UnitGroupAdd(libMSHE_gv_mMISShrineGroups[2], libMSHE_gv_mMISShrines[2]);

    UnitGroupAdd(libMSHE_gv_mMISShrineGroups[3], libMSHE_gv_mMISShrines[3]);

    libMSHE_gv_mMISMonsterShrine = lp_monsterShrine;

}



void libMSHE_gf_MMISTextTagScoreHandler (int lp_enemyTeam, int lp_team, unit lp_currentShrine) {

    // Variable Declarations

    int lv_itPlayer;



    // Automatic Variable Declarations

    playergroup auto1A5B44D4_g;



    // Variable Initialization



    // Implementation

    if ((libMSHE_gv_mMISTextTag[lp_team] == c_textTagNone)) {

        TextTagCreate(StringExternal("Param/Value/lib_MSHE_8C8796B4"), 24, UnitGetPosition(lp_currentShrine), 1.0, true, false, libGame_gf_PlayersOnTeamHeroes(lp_team, false));

        libMSHE_gv_mMISTextTag[lp_team] = TextTagLastCreated();

    }



    if ((libMSHE_gv_mMISKillCount[lp_team] >= libMSHE_gv_mMDiabloShrineCursedEventTotal_C)) {

        TextTagDestroy(libMSHE_gv_mMISTextTag[lp_team]);

        if ((lp_enemyTeam <= libCore_gv_bALMaxTeams)) {

            TextTagDestroy(libMSHE_gv_mMISTextTag[lp_enemyTeam]);

        }



        libMSHE_gv_mMISTextTag[lp_team] = c_textTagNone;

        libMSHE_gv_mMISTextTag[lp_enemyTeam] = c_textTagNone;

    }

    else {

        auto1A5B44D4_g = libGame_gf_PlayersOnTeamHeroes(lp_team, false);

        lv_itPlayer = -1;

        while (true) {

            	lv_itPlayer = PlayerGroupNextPlayer(auto1A5B44D4_g, lv_itPlayer);

            	if (lv_itPlayer<0) { break; }

            	TextExpressionSetToken("Param/Expression/lib_MSHE_D32CCB19", "A", IntToText(libMSHE_gv_mMISKillCount[lp_team]));

            TextExpressionSetToken("Param/Expression/lib_MSHE_D32CCB19", "B", IntToText(libMSHE_gv_mMDiabloShrineCursedEventTotal_C));

            TextTagSetText(libMSHE_gv_mMISTextTag[lp_team], TextExpressionAssemble("Param/Expression/lib_MSHE_D32CCB19"));

        }

    }

}



void libMSHE_gf_MMISRandomizeNextShrineandShowPreview () {

    // Automatic Variable Declarations

    int autoED96EF13_val;



    // Implementation

    if ((libCore_gv_dEBUGDebuggingEnabled == true) && (libMSHE_gv_forcedPunisherType != 0)) {

        libMSHE_gv_mMISLastShrineCounter += 1;

        libMSHE_gv_mMISCurrentShrine = RandomInt(1, libMSHE_gv_mMISNumberofShrinesAllowed);

        libMSHE_gv_mMISBuffIndex = libMSHE_gv_forcedPunisherType;

    }

    else {

        if ((libMSHE_gv_mMISNumberOfShrinesEvents == 0)) {

            libMSHE_gv_mMISCurrentShrine = RandomInt(1, libMSHE_gv_mMISNumberofShrinesAllowed);

            libMSHE_gv_mMISBuffIndex = libMSHE_gf_MMISGetWhichShrine();

        }

        else {

            while (((libMSHE_gv_mMISLastShrineCounter < 15) && ((libMSHE_gv_mMISCurrentShrine == libMSHE_gv_mMISLastShrine) || (libMSHE_gv_mMISBuffIndex == libMSHE_gv_mMISLastBuff)))) {

                libMSHE_gv_mMISLastShrineCounter += 1;

                libMSHE_gv_mMISCurrentShrine = RandomInt(1, libMSHE_gv_mMISNumberofShrinesAllowed);

                libMSHE_gv_mMISBuffIndex = libMSHE_gf_MMISGetWhichShrine();

            }

        }

    }

    libNtve_gf_SendActorMessageToUnit(libMSHE_gv_mMISShrines[libMSHE_gv_mMISCurrentShrine], "SetMinimapVisibility 1");

    libNtve_gf_SendActorMessageToUnit(libMSHE_gv_mMISShrines[libMSHE_gv_mMISCurrentShrine], "SetMinimapVisibilityAlways 1");

    autoED96EF13_val = libMSHE_gv_mMISBuffIndex;

    if (autoED96EF13_val == 1) {

        libNtve_gf_SendActorMessageToUnit(libMSHE_gv_mMISShrines[libMSHE_gv_mMISCurrentShrine], "MinimapTooltip DOCSTR_InactiveFrozenShrine");

    }

    else if (autoED96EF13_val == 2) {

        libNtve_gf_SendActorMessageToUnit(libMSHE_gv_mMISShrines[libMSHE_gv_mMISCurrentShrine], "MinimapTooltip DOCSTR_InactiveMortarShrine");

    }

    else if (autoED96EF13_val == 3) {

        libNtve_gf_SendActorMessageToUnit(libMSHE_gv_mMISShrines[libMSHE_gv_mMISCurrentShrine], "MinimapTooltip DOCSTR_InactiveArcaneShrine");

    }

    else {

    }

}



int libMSHE_gf_MMISGetWhichShrine () {

    // Variable Declarations

    int lv_itShrine;

    int lv_shrine;



    // Automatic Variable Declarations

    int auto29E50C5F_ae;

    const int auto29E50C5F_ai = 1;



    // Variable Initialization



    // Implementation

    if ((PlayerGroupCount(libMSHE_gv_mMISShrineGroup) == 0)) {

        auto29E50C5F_ae = libMSHE_gv_mMISNumberofShrinesAllowed;

        lv_itShrine = 1;

        for ( ; ( (auto29E50C5F_ai >= 0 && lv_itShrine <= auto29E50C5F_ae) || (auto29E50C5F_ai < 0 && lv_itShrine >= auto29E50C5F_ae) ) ; lv_itShrine += auto29E50C5F_ai ) {

            PlayerGroupAdd(libMSHE_gv_mMISShrineGroup, lv_itShrine);

        }

    }



    lv_shrine = PlayerGroupPlayer(libMSHE_gv_mMISShrineGroup, RandomInt(1, PlayerGroupCount(libMSHE_gv_mMISShrineGroup)));

    return lv_shrine;

}



void libMSHE_gf_MMISActivateShrine (int lp_shrine) {

    // Variable Declarations

    unit lv_shrineIconUnit;

    unitgroup lv_shrine;

    int lv_shrineType;

    unit lv_itUnit;



    // Automatic Variable Declarations

    unitgroup auto6F20D935_g;

    int auto6F20D935_u;

    unit auto6F20D935_var;

    unitgroup autoE5CA2A3B_g;

    int autoE5CA2A3B_u;

    unit autoE5CA2A3B_var;

    string auto318ED688_val;



    // Variable Initialization

    lv_shrine = UnitGroupEmpty();

    lv_shrineType = libMSHE_ge_MMISShrineTypes_None;



    // Implementation

    libMSHE_gv_mMISLastShrine = lp_shrine;

    libMSHE_gv_mMISLastBuff = libMSHE_gv_mMISBuffIndex;

    UnitRemove(libMSHE_gv_mMISWarningUnit);

    auto6F20D935_g = UnitGroup("DiabloShrine", c_playerAny, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);

    auto6F20D935_u = UnitGroupCount(auto6F20D935_g, c_unitCountAll);

    for (;; auto6F20D935_u -= 1) {

        auto6F20D935_var = UnitGroupUnitFromEnd(auto6F20D935_g, auto6F20D935_u);

        if (auto6F20D935_var == null) { break; }

        UnitAbilityEnable(auto6F20D935_var, "CursedShrineSpawn", true);

    }

    autoE5CA2A3B_g = libMSHE_gv_mMISShrineGroups[lp_shrine];

    autoE5CA2A3B_u = UnitGroupCount(autoE5CA2A3B_g, c_unitCountAll);

    for (;; autoE5CA2A3B_u -= 1) {

        autoE5CA2A3B_var = UnitGroupUnitFromEnd(autoE5CA2A3B_g, autoE5CA2A3B_u);

        if (autoE5CA2A3B_var == null) { break; }

        lv_shrineIconUnit = autoE5CA2A3B_var;

        UnitSetOwner(autoE5CA2A3B_var, 0, true);

    }

    UnitBehaviorAdd(libMSHE_gv_mMISShrines[lp_shrine], libMSHE_gv_mMISBuff, libMSHE_gv_mMISShrines[lp_shrine], 1);

    UnitBehaviorAdd(libMSHE_gv_mMISShrines[lp_shrine], "MacguffinActivated", libMSHE_gv_mMISShrines[lp_shrine], 1);

    UnitSetState(libMSHE_gv_mMISShrines[lp_shrine], c_unitStateHighlightable, true);

    UnitSetState(libMSHE_gv_mMISShrines[lp_shrine], c_unitStateTargetable, true);

    UnitGroupAdd(libMSHE_gv_mMISActiveShrines, libMSHE_gv_mMISShrines[lp_shrine]);

    libNtve_gf_SendActorMessageToUnit(libMSHE_gv_mMISShrines[lp_shrine], "Signal Event");

    libNtve_gf_SendActorMessageToUnit(libMSHE_gv_mMISShrines[lp_shrine], "MinimapIconTintColor 255,217,186,123");

    auto318ED688_val = libMSHE_gv_mMISBuff;

    if (auto318ED688_val == "ArcaneShrine") {

        ActorSend(libNtve_gf_MainActorofUnit(libMSHE_gv_mMISShrines[lp_shrine]), "Signal Arcane");

        libNtve_gf_SendActorMessageToUnit(libMSHE_gv_mMISShrines[lp_shrine], "MinimapTooltip DOCSTR_ArcaneShrine");

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

    }

    else if (auto318ED688_val == "FrozenShrine") {

        ActorSend(libNtve_gf_MainActorofUnit(libMSHE_gv_mMISShrines[lp_shrine]), "Signal Frozen");

        libNtve_gf_SendActorMessageToUnit(libMSHE_gv_mMISShrines[lp_shrine], "MinimapTooltip DOCSTR_FrozenShrine");

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

    }

    else if (auto318ED688_val == "BombardShrine") {

        ActorSend(libNtve_gf_MainActorofUnit(libMSHE_gv_mMISShrines[lp_shrine]), "Signal Mortar");

        libNtve_gf_SendActorMessageToUnit(libMSHE_gv_mMISShrines[lp_shrine], "MinimapTooltip DOCSTR_MortarShrine");

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

    }

    else {

    }

    libMSHE_gv_mMISTotalShrineCount = 1;

    TextTagCreate(StringExternal("Param/Value/lib_MSHE_31E94D19"), 24, UnitGetPosition(libMSHE_gv_mMISShrines[lp_shrine]), 1.0, true, false, libGame_gf_PlayersOnTeamHeroes(1, false));

    libMSHE_gv_mMISTextTag[1] = TextTagLastCreated();

    TextTagCreate(StringExternal("Param/Value/lib_MSHE_C100DE4B"), 24, UnitGetPosition(libMSHE_gv_mMISShrines[lp_shrine]), 1.0, true, false, libGame_gf_PlayersOnTeamHeroes(2, false));

    libMSHE_gv_mMISTextTag[2] = TextTagLastCreated();

    TimerStart(libMSHE_gv_mMISShrineReminderTimer, libMSHE_gv_mMISShrineReminderDelay_C, false, c_timeGame);

    TimerStart(libMSHE_gv_mMISShrineNotificationTimer, libMSHE_gv_mMISShrineNotificationDelay_C, false, c_timeGame);

}



void libMSHE_gf_MMISAnnouncementShrineCaptured (unit lp_shrineUnit, int lp_shrine, int lp_team) {

    // Automatic Variable Declarations

    // Implementation

    if ((lp_team == libGame_gv_teamOrderIndex_C)) {

        MinimapPing(libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroup, UnitGetPosition(lp_shrineUnit), 5.0, Color(0.00, 33.33, 100.00));

        MinimapPing(libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroup, UnitGetPosition(lp_shrineUnit), 5.0, Color(100.00, 0.00, 0.00));

        MinimapPing(libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer], UnitGetPosition(lp_shrineUnit), 5.0, Color(0.00, 33.33, 100.00));

        SoundPlayForPlayer(SoundLink("UI_Game_Ping_InfernalShrine_Captured_Ally", -1), lp_team, libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroup, 100.0, 0.0);

        SoundPlayForPlayer(SoundLink("UI_Game_Ping_InfernalShrine_Captured_Enemy", -1), lp_team, libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroup, 100.0, 0.0);

    }

    else {

        MinimapPing(libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroup, UnitGetPosition(lp_shrineUnit), 5.0, Color(100.00, 0.00, 0.00));

        MinimapPing(libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroup, UnitGetPosition(lp_shrineUnit), 5.0, Color(0.00, 33.33, 100.00));

        MinimapPing(libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer], UnitGetPosition(lp_shrineUnit), 5.0, Color(100.00, 0.00, 0.00));

        SoundPlayForPlayer(SoundLink("UI_Game_Ping_InfernalShrine_Captured_Enemy", -1), lp_team, libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroup, 100.0, 0.0);

        SoundPlayForPlayer(SoundLink("UI_Game_Ping_InfernalShrine_Captured_Ally", -1), lp_team, libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroup, 100.0, 0.0);

    }

}



void libMSHE_gf_MMISWarningAnnouncementShrine (int lp_shrine) {

    // Automatic Variable Declarations

    // Implementation

    libCore_gf_CreateMinimapPingStorm(PlayerGroupAll(), "StormAlert", UnitGetPosition(libMSHE_gv_mMISShrines[lp_shrine]), ColorWithAlpha(100.00, 100.00, 0.00, 0.00), libMSHE_gv_mMDiabloShrinesShrineTimerWarning);

    libMSHE_gf_MMISTransmissionShrineWarningActivating();

    UnitBehaviorAdd(libMSHE_gv_mMISShrines[lp_shrine], "DiabloShrineWarningFX", libMSHE_gv_mMISShrines[lp_shrine], 1);

    VisRevealerCreate(libCore_gv_cOMPUTER_TeamOrder, RegionCircle(UnitGetPosition(libMSHE_gv_mMISShrines[lp_shrine]), libMapM_gv_mMRavenRevealRadius_C));

    libMSHE_gv_mMISRevealers[1] = VisRevealerLastCreated();

    VisRevealerCreate(libCore_gv_cOMPUTER_TeamChaos, RegionCircle(UnitGetPosition(libMSHE_gv_mMISShrines[lp_shrine]), libMapM_gv_mMRavenRevealRadius_C));

    libMSHE_gv_mMISRevealers[2] = VisRevealerLastCreated();

    libNtve_gf_SendActorMessageToUnit(libMSHE_gv_mMISShrines[lp_shrine], "Signal Warning");

}



trigger auto_libMSHE_gf_MMISGrantShrineRewardToTeam_Trigger = null;

int auto_libMSHE_gf_MMISGrantShrineRewardToTeam_lp_team;

unit auto_libMSHE_gf_MMISGrantShrineRewardToTeam_lp_shrine;

string auto_libMSHE_gf_MMISGrantShrineRewardToTeam_lp_shrineBuff;



void libMSHE_gf_MMISGrantShrineRewardToTeam (int lp_team, unit lp_shrine, string lp_shrineBuff) {

    auto_libMSHE_gf_MMISGrantShrineRewardToTeam_lp_team = lp_team;

    auto_libMSHE_gf_MMISGrantShrineRewardToTeam_lp_shrine = lp_shrine;

    auto_libMSHE_gf_MMISGrantShrineRewardToTeam_lp_shrineBuff = lp_shrineBuff;



    if (auto_libMSHE_gf_MMISGrantShrineRewardToTeam_Trigger == null) {

        auto_libMSHE_gf_MMISGrantShrineRewardToTeam_Trigger = TriggerCreate("auto_libMSHE_gf_MMISGrantShrineRewardToTeam_TriggerFunc");

    }



    TriggerExecute(auto_libMSHE_gf_MMISGrantShrineRewardToTeam_Trigger, false, false);

}



bool auto_libMSHE_gf_MMISGrantShrineRewardToTeam_TriggerFunc (bool testConds, bool runActions) {

    int lp_team = auto_libMSHE_gf_MMISGrantShrineRewardToTeam_lp_team;

    unit lp_shrine = auto_libMSHE_gf_MMISGrantShrineRewardToTeam_lp_shrine;

    string lp_shrineBuff = auto_libMSHE_gf_MMISGrantShrineRewardToTeam_lp_shrineBuff;



    // Variable Declarations

    unit lv_itUnit;

    int lv_itPlayer;

    int lv_p;

    int lv_untitledVariable001;

    int lv_slot;



    // Automatic Variable Declarations

    unitgroup autoF717E312_g;

    int autoF717E312_u;

    unit autoF717E312_var;

    unitgroup auto057A52B1_g;

    int auto057A52B1_u;

    unit auto057A52B1_var;



    // Variable Initialization



    // Implementation

    libMSHE_gv_mMISShrineIsActive = false;

    libMSHE_gv_mMISBuffedTeam = lp_team;

    DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_punisherArcaneAllyIcon, PlayerGroupAll(), false);

    DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_punisherArcaneEnemyIcon, PlayerGroupAll(), false);

    DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_punisherFrozenAllyIcon, PlayerGroupAll(), false);

    DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_punisherFrozenEnemyIcon, PlayerGroupAll(), false);

    DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_punisherMortarAllyIcon, PlayerGroupAll(), false);

    DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_punisherMortarEnemyIcon, PlayerGroupAll(), false);

    if ((UnitHasBehavior2(lp_shrine, "ArcaneShrine") == true)) {

        DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_punisherArcaneAllyIcon, libGame_gv_teams[lp_team].lv_teamPlayerGroupNoNPCPlayers, true);

        DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_punisherArcaneEnemyIcon, libGame_gv_teams[libGame_gf_EnemyTeam(lp_team)].lv_teamPlayerGroupNoNPCPlayers, true);

        if ((lp_team == libGame_gv_teamOrderIndex_C)) {

            DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_punisherArcaneAllyIcon, libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer], true);

        }

        else {

            DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_punisherArcaneEnemyIcon, libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer], true);

        }

    }



    if ((UnitHasBehavior2(lp_shrine, "FrozenShrine") == true)) {

        DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_punisherFrozenAllyIcon, libGame_gv_teams[lp_team].lv_teamPlayerGroupNoNPCPlayers, true);

        DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_punisherFrozenEnemyIcon, libGame_gv_teams[libGame_gf_EnemyTeam(lp_team)].lv_teamPlayerGroupNoNPCPlayers, true);

        if ((lp_team == libGame_gv_teamOrderIndex_C)) {

            DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_punisherFrozenAllyIcon, libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer], true);

        }

        else {

            DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_punisherFrozenEnemyIcon, libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer], true);

        }

    }



    if ((UnitHasBehavior2(lp_shrine, "BombardShrine") == true)) {

        DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_punisherMortarAllyIcon, libGame_gv_teams[lp_team].lv_teamPlayerGroupNoNPCPlayers, true);

        DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_punisherMortarEnemyIcon, libGame_gv_teams[libGame_gf_EnemyTeam(lp_team)].lv_teamPlayerGroupNoNPCPlayers, true);

        if ((lp_team == libGame_gv_teamOrderIndex_C)) {

            DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_punisherMortarAllyIcon, libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer], true);

        }

        else {

            DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_punisherMortarEnemyIcon, libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer], true);

        }

    }



    UnitSetOwner(lp_shrine, libGame_gf_ComputerPlayerInTeam(lp_team), true);

    libNtve_gf_CreateUnitsWithDefaultFacing(1, "RegenGlobe", 0, libGame_gf_ComputerPlayerInTeam(lp_team), PointWithOffset(UnitGetPosition(lp_shrine), 2.0, 0.0), null);

    libNtve_gf_CreateUnitsWithDefaultFacing(1, "RegenGlobe", 0, libGame_gf_ComputerPlayerInTeam(lp_team), PointWithOffset(UnitGetPosition(lp_shrine), -2.0, 0.0), null);

    autoF717E312_g = UnitGroup("DiabloShrine", c_playerAny, null, UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);

    autoF717E312_u = UnitGroupCount(autoF717E312_g, c_unitCountAll);

    for (;; autoF717E312_u -= 1) {

        autoF717E312_var = UnitGroupUnitFromEnd(autoF717E312_g, autoF717E312_u);

        if (autoF717E312_var == null) { break; }

        UnitAbilityEnable(autoF717E312_var, "CursedShrineSpawn", false);

    }

    ActorSend(libNtve_gf_MainActorofUnit(lp_shrine), "MinimapIconTintColor 255,145,113,218");

    ActorSend(libNtve_gf_MainActorofUnit(lp_shrine), "SetMinimapVisibility");

    ActorSend(libNtve_gf_MainActorofUnit(lp_shrine), "SetMinimapVisibilityAlways");

    TimerStart(libMSHE_gv_mMISPunisherSpawnTimer, 3.7, false, c_timeGame);

    if ((lp_team == libGame_gv_teamOrderIndex_C)) {

        libNtve_gf_SendActorMessageToUnit(lp_shrine, "Signal OpenRight");

    }

    else {

        libNtve_gf_SendActorMessageToUnit(lp_shrine, "Signal OpenLeft");

    }

    Wait(0.8, c_timeGame);

    libSond_gf_SoundtrackApplyNewDefaultSoundtrackForPlayerGroup("MX_Event_Shrines_Punisher_In_Lane", PlayerGroupAll());

    libNtve_gf_SendActorMessageToUnit(lp_shrine, "Signal Birth");

    VisRevealerDestroy(libMSHE_gv_mMISRevealers[1]);

    VisRevealerDestroy(libMSHE_gv_mMISRevealers[2]);

    Wait(3.0, c_timeGame);

    TriggerEnable(libMSHE_gt_MMISStartShrineTimer, true);

    if ((UnitHasBehavior2(lp_shrine, "FrozenShrine") == true)) {

        libMSHE_gf_MMISSpawnShrineMonster(libMSHE_ge_MMISShrineTypes_FrozenShrine, lp_team);

        libMSHE_gv_mMISTotalShrineCount -= 1;

        Wait(1.0, c_timeGame);

        ActorSend(libNtve_gf_MainActorofUnit(lp_shrine), "Signal Deactivate");

        UnitBehaviorRemove(lp_shrine, "FrozenShrine", 1);

        UnitBehaviorRemove(lp_shrine, "MonsterShrine", 1);

        UnitBehaviorRemove(lp_shrine, "MacguffinActivated", 1);

        Wait(0.5, c_timeGame);

        UnitSetOwner(lp_shrine, libCore_gv_cOMPUTER_Neutral, true);

        return true;

    }



    if ((UnitHasBehavior2(lp_shrine, "ArcaneShrine") == true)) {

        libMSHE_gf_MMISSpawnShrineMonster(libMSHE_ge_MMISShrineTypes_ArcaneShrine, lp_team);

        libMSHE_gv_mMISTotalShrineCount -= 1;

        Wait(1.0, c_timeGame);

        ActorSend(libNtve_gf_MainActorofUnit(lp_shrine), "Signal Deactivate");

        UnitBehaviorRemove(lp_shrine, "ArcaneShrine", 1);

        UnitBehaviorRemove(lp_shrine, "CombatShrine", 1);

        UnitBehaviorRemove(lp_shrine, "MacguffinActivated", 1);

        Wait(0.5, c_timeGame);

        UnitSetOwner(lp_shrine, libCore_gv_cOMPUTER_Neutral, true);

        return true;

    }



    if ((UnitHasBehavior2(lp_shrine, "BombardShrine") == true)) {

        libMSHE_gf_MMISSpawnShrineMonster(libMSHE_ge_MMISShrineTypes_BombardShrine, lp_team);

        libMSHE_gv_mMISTotalShrineCount -= 1;

        Wait(1.0, c_timeGame);

        ActorSend(libNtve_gf_MainActorofUnit(lp_shrine), "Signal Deactivate");

        UnitBehaviorRemove(lp_shrine, "BombardShrine", 1);

        UnitBehaviorRemove(lp_shrine, "SiegeShrine", 1);

        UnitBehaviorRemove(lp_shrine, "MacguffinActivated", 1);

        Wait(0.5, c_timeGame);

        UnitSetOwner(lp_shrine, libCore_gv_cOMPUTER_Neutral, true);

        return true;

    }



    UnitBehaviorRemove(lp_shrine, "CombatShrine", 1);

    UnitBehaviorRemove(lp_shrine, "SiegeShrine", 1);

    UnitBehaviorRemove(lp_shrine, "MonsterShrine", 1);

    UnitBehaviorRemove(lp_shrine, "FrozenShrine", 1);

    UnitBehaviorRemove(lp_shrine, "BombardShrine", 1);

    UnitBehaviorRemove(lp_shrine, "ThunderstormShrine", 1);

    UnitBehaviorRemove(lp_shrine, "ArcaneShrine", 1);

    UnitBehaviorRemove(lp_shrine, "MacguffinActivated", 1);

    auto057A52B1_g = UnitGroup("CursedShrineMinion", c_playerAny, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);

    auto057A52B1_u = UnitGroupCount(auto057A52B1_g, c_unitCountAll);

    for (;; auto057A52B1_u -= 1) {

        auto057A52B1_var = UnitGroupUnitFromEnd(auto057A52B1_g, auto057A52B1_u);

        if (auto057A52B1_var == null) { break; }

        UnitRemove(auto057A52B1_var);

    }

    return true;

}



string libMSHE_gf_MMISGetIconForShrine (int lp_shrine) {

    // Automatic Variable Declarations

    int auto63B5FC0B_val;



    // Implementation

    auto63B5FC0B_val = lp_shrine;

    if (auto63B5FC0B_val == libMSHE_ge_MMISShrineTypes_None) {

        return null;

    }

    else if (auto63B5FC0B_val == libMSHE_ge_MMISShrineTypes_CombatShrine) {

        return "Assets\\Textures\\storm_bloodlusta.dds";

    }

    else if (auto63B5FC0B_val == libMSHE_ge_MMISShrineTypes_SiegeShrine) {

        return "Assets\\Textures\\storm_ui_icon_sgthammer_siegemode.dds";

    }

    else if (auto63B5FC0B_val == libMSHE_ge_MMISShrineTypes_MonsterShrine) {

        return "Assets\\Textures\\storm_btn_d3_wizard_hydra.dds";

    }

    else if (auto63B5FC0B_val == libMSHE_ge_MMISShrineTypes_FrozenShrine) {

        return "Assets\\Textures\\storm_btn_d3_wizard_hydra.dds";

    }

    else if (auto63B5FC0B_val == libMSHE_ge_MMISShrineTypes_BombardShrine) {

        return "Assets\\Textures\\storm_btn_d3_wizard_hydra.dds";

    }

    else if (auto63B5FC0B_val == libMSHE_ge_MMISShrineTypes_ThunderstormShrine) {

        return "Assets\\Textures\\storm_btn_d3_wizard_hydra.dds";

    }

    else if (auto63B5FC0B_val == libMSHE_ge_MMISShrineTypes_ArcaneShrine) {

        return "Assets\\Textures\\storm_btn_d3_wizard_hydra.dds";

    }

    else {

        return null;

    }

}



text libMSHE_gf_MMISGetShrineText (int lp_shrine) {

    // Automatic Variable Declarations

    int auto912B8757_val;



    // Implementation

    auto912B8757_val = lp_shrine;

    if (auto912B8757_val == libMSHE_ge_MMISShrineTypes_None) {

        return null;

    }

    else if (auto912B8757_val == libMSHE_ge_MMISShrineTypes_ThunderstormShrine) {

        return StringExternal("Param/Value/lib_MSHE_9ABE357E");

    }

    else if (auto912B8757_val == libMSHE_ge_MMISShrineTypes_BombardShrine) {

        return StringExternal("Param/Value/lib_MSHE_930CAFC6");

    }

    else if (auto912B8757_val == libMSHE_ge_MMISShrineTypes_FrozenShrine) {

        return StringExternal("Param/Value/lib_MSHE_B3B4304E");

    }

    else if (auto912B8757_val == libMSHE_ge_MMISShrineTypes_CombatShrine) {

        return StringExternal("Param/Value/lib_MSHE_06FFAB3A");

    }

    else if (auto912B8757_val == libMSHE_ge_MMISShrineTypes_SiegeShrine) {

        return StringExternal("Param/Value/lib_MSHE_3D3C5D9E");

    }

    else if (auto912B8757_val == libMSHE_ge_MMISShrineTypes_MonsterShrine) {

        return StringExternal("Param/Value/lib_MSHE_A1283BAF");

    }

    else if (auto912B8757_val == libMSHE_ge_MMISShrineTypes_ArcaneShrine) {

        return StringExternal("Param/Value/lib_MSHE_43047435");

    }

    else {

        return null;

    }

}



string libMSHE_gf_MMISGetBuffForShrine (int lp_shrine) {

    // Automatic Variable Declarations

    int auto70A1BA51_val;



    // Implementation

    auto70A1BA51_val = lp_shrine;

    if (auto70A1BA51_val == libMSHE_ge_MMISShrineTypes_None) {

        return null;

    }

    else if (auto70A1BA51_val == libMSHE_ge_MMISShrineTypes_CombatShrine) {

        return "CombatShrineBuff";

    }

    else if (auto70A1BA51_val == libMSHE_ge_MMISShrineTypes_MonsterShrine) {

        return "MonsterShrineBuff";

    }

    else if (auto70A1BA51_val == libMSHE_ge_MMISShrineTypes_SiegeShrine) {

        return "SiegeShrineBuff";

    }

    else if (auto70A1BA51_val == libMSHE_ge_MMISShrineTypes_FrozenShrine) {

        return "FrozenShrineBuff";

    }

    else if (auto70A1BA51_val == libMSHE_ge_MMISShrineTypes_BombardShrine) {

        return "BombardShrineBuff";

    }

    else if (auto70A1BA51_val == libMSHE_ge_MMISShrineTypes_ThunderstormShrine) {

        return "ThunderstormShrineBuff";

    }

    else if (auto70A1BA51_val == libMSHE_ge_MMISShrineTypes_ArcaneShrine) {

        return "ArcaneShrineBuff";

    }

    else {

        return null;

    }

}



void libMSHE_gf_MMISSpawnShrineMonster (int lp_affix, int lp_team) {

    // Variable Declarations

    unit lv_monster;

    int lv_enemyTeam;



    // Automatic Variable Declarations

    int auto22777E7A_val;



    // Variable Initialization



    // Implementation

    libMSHE_gf_MMISTransmissionPunisherSummoned(lp_team, lp_affix);

    lv_enemyTeam = (3 - lp_team);

    if ((lp_team == libGame_gv_teamOrderIndex_C)) {

        UnitCreate(1, "MercPunisherLaner", 0, libGame_gf_ComputerPlayerInTeam(lp_team), PointWithOffset(UnitGetPosition(libMSHE_gv_mMISShrines[libMSHE_gv_mMISCurrentShrine]), 1.826, -5.018), -70.0, null);

    }

    else {

        UnitCreate(1, "MercPunisherLaner", 0, libGame_gf_ComputerPlayerInTeam(lp_team), PointWithOffset(UnitGetPosition(libMSHE_gv_mMISShrines[libMSHE_gv_mMISCurrentShrine]), -1.826, -5.018), -110.0, null);

    }

    UnitXPAddXP(UnitLastCreated(), null, libMSHE_gv_mMISMonsterXP);

    auto22777E7A_val = lp_affix;

    if (auto22777E7A_val == libMSHE_ge_MMISShrineTypes_FrozenShrine) {

        UnitBehaviorAdd(UnitLastCreated(), "DiabloFrozen", UnitLastCreated(), 1);

        libNtve_gf_SendActorMessageToUnit(UnitLastCreated(), "ModelSwap MercPunisherLanerFrozen");

        libNtve_gf_SendActorMessageToUnit(UnitLastCreated(), "MinimapTooltip DOCSTR_FrozenPunisher");

        libNtve_gf_SendActorMessageToUnit(UnitLastCreated(), "SetGroupIcon 0 Assets\\Textures\\Storm_UI_InGame_TargetInfoPanel_Unit_InfernalShrines_Boss_Punisher_Frozen.dds");

    }

    else if (auto22777E7A_val == libMSHE_ge_MMISShrineTypes_ArcaneShrine) {

        UnitBehaviorAdd(UnitLastCreated(), "DiabloArcane", UnitLastCreated(), 1);

        libNtve_gf_SendActorMessageToUnit(UnitLastCreated(), "ModelSwap MercPunisherLanerArcane");

        libNtve_gf_SendActorMessageToUnit(UnitLastCreated(), "MinimapTooltip DOCSTR_ArcanePunisher");

        libNtve_gf_SendActorMessageToUnit(UnitLastCreated(), "SetGroupIcon 0 Assets\\Textures\\Storm_UI_InGame_TargetInfoPanel_Unit_InfernalShrines_Boss_Punisher_Arcane.dds");

    }

    else if (auto22777E7A_val == libMSHE_ge_MMISShrineTypes_BombardShrine) {

        UnitBehaviorAdd(UnitLastCreated(), "DiabloMortar", UnitLastCreated(), 1);

        libNtve_gf_SendActorMessageToUnit(UnitLastCreated(), "ModelSwap MercPunisherLanerMortar");

        libNtve_gf_SendActorMessageToUnit(UnitLastCreated(), "MinimapTooltip DOCSTR_MortarPunisher");

        libNtve_gf_SendActorMessageToUnit(UnitLastCreated(), "SetGroupIcon 0 Assets\\Textures\\Storm_UI_InGame_TargetInfoPanel_Unit_InfernalShrines_Boss_Punisher_Mortar.dds");

    }

    else {

    }

    lv_monster = UnitLastCreated();

    libMSHE_gv_mMISPunisher = UnitLastCreated();

    TriggerEnable(libMSHE_gt_PunisherDurationTracking, true);

    libGame_gf_CalculateSpawnedMinionGoalPoints(lp_team, UnitGetPosition(lv_monster));

    libAIAI_gf_MinionAIStartMinionAI(-1, lv_monster, libGame_gv_spawnedMinionLane, libGame_gv_spawnedMinionFirstWaypointIndex, false, true, false, lv_enemyTeam, false);

    libMSHE_gv_mMDiabloShrinesPunisherPushLane = AILaneWaypointGetClosestLane(UnitGetPosition(lv_monster));

}



void libMSHE_gf_MMBOEUpdateAmbience (int lp_player) {

    // Automatic Variable Declarations

    // Implementation

    if ((PointGetX(CameraGetTarget(lp_player)) > 124.0)) {

        libMSHE_gf_MMBOEChangeAmbience("Ambience_BoE_Hell", null, PlayerGroupSingle(lp_player));

    }

    else if ((PointGetX(CameraGetTarget(lp_player)) < 124.0)) {

        libMSHE_gf_MMBOEChangeAmbience("Ambience_BoE_Heaven", null, PlayerGroupSingle(lp_player));

    }

}



void libMSHE_gf_MMBOEChangeAmbience (string lp_ambience, string lp_reverb, playergroup lp_players) {

    // Variable Declarations

    int lv_itPlayer;



    // Automatic Variable Declarations

    playergroup auto57337A48_g;



    // Variable Initialization



    // Implementation

    auto57337A48_g = lp_players;

    lv_itPlayer = -1;

    while (true) {

        	lv_itPlayer = PlayerGroupNextPlayer(auto57337A48_g, lv_itPlayer);

        	if (lv_itPlayer<0) { break; }

        	if ((libMSHE_gv_mMUnderworldAmbience[lv_itPlayer] == lp_ambience)) {

            continue;

        }



        libMSHE_gv_mMUnderworldAmbience[lv_itPlayer] = lp_ambience;

        SoundtrackPlay(libCore_gv_playerGroupFromPlayer[lv_itPlayer], c_soundtrackCategoryAmbience, lp_ambience, c_soundtrackCueAny, c_soundtrackIndexAny, true);

    }

}



trigger auto_libMSHE_gf_MMISTransmissionShrineWarningActivating_Trigger = null;



void libMSHE_gf_MMISTransmissionShrineWarningActivating () {

    if (auto_libMSHE_gf_MMISTransmissionShrineWarningActivating_Trigger == null) {

        auto_libMSHE_gf_MMISTransmissionShrineWarningActivating_Trigger = TriggerCreate("auto_libMSHE_gf_MMISTransmissionShrineWarningActivating_TriggerFunc");

    }



    TriggerExecute(auto_libMSHE_gf_MMISTransmissionShrineWarningActivating_Trigger, false, false);

}



bool auto_libMSHE_gf_MMISTransmissionShrineWarningActivating_TriggerFunc (bool testConds, bool runActions) {

    // Variable Declarations

    playergroup lv_groupAngel;

    playergroup lv_groupDemon;

    playergroup lv_groupObserver;

    int lv_itLineIndex;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_groupAngel = PlayerGroupEmpty();

    lv_groupDemon = PlayerGroupEmpty();

    lv_groupObserver = PlayerGroupEmpty();



    // Implementation

    if ((libGame_gv_gameOver == true)) {

        return true;

    }



    TriggerQueueEnter();

    UserDataResetType("MapVOEvent");

    ConversationDataLineResetPlayers("ShrinesVO", ("Angel"));

    ConversationDataLineResetPlayers("ShrinesVO", ("Demon"));

    if ((libMSHE_gv_mMISNumberOfShrinesEvents > 0)) {

        UserDataSetInt("MapVOEvent", "Shrine Activating", "Value", 1, 1);

    }

    else {

        UserDataSetInt("MapVOEvent", "Shrine Activating First", "Value", 1, 1);

    }

    lv_groupAngel = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamOrderIndex_C, false);

    lv_groupDemon = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamChaosIndex_C, false);

    lv_groupObserver = libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer];

    libNtve_gf_AddPlayerGroupToPlayerGroup(lv_groupObserver, lv_groupDemon);

    ConversationDataLineSetPlayers("ShrinesVO", ("Angel"), lv_groupAngel);

    ConversationDataLineSetPlayers("ShrinesVO", ("Demon"), lv_groupDemon);

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

    libCore_gf_WaitForConversationToFinish();

    TriggerQueueExit();

    return true;

}



trigger auto_libMSHE_gf_MMISTransmissionShrineActivating_Trigger = null;



void libMSHE_gf_MMISTransmissionShrineActivating () {

    if (auto_libMSHE_gf_MMISTransmissionShrineActivating_Trigger == null) {

        auto_libMSHE_gf_MMISTransmissionShrineActivating_Trigger = TriggerCreate("auto_libMSHE_gf_MMISTransmissionShrineActivating_TriggerFunc");

    }



    TriggerExecute(auto_libMSHE_gf_MMISTransmissionShrineActivating_Trigger, false, false);

}



bool auto_libMSHE_gf_MMISTransmissionShrineActivating_TriggerFunc (bool testConds, bool runActions) {

    // Variable Declarations

    playergroup lv_groupAngel;

    playergroup lv_groupDemon;

    playergroup lv_groupObserver;

    int lv_itLineIndex;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_groupAngel = PlayerGroupEmpty();

    lv_groupDemon = PlayerGroupEmpty();

    lv_groupObserver = PlayerGroupEmpty();



    // Implementation

    if ((libGame_gv_gameOver == true)) {

        return true;

    }



    TriggerQueueEnter();

    UserDataResetType("MapVOEvent");

    ConversationDataLineResetPlayers("ShrinesVO", ("Angel"));

    ConversationDataLineResetPlayers("ShrinesVO", ("Demon"));

    ConversationDataLineResetPlayers("ShrinesVO", ("Observer"));

    if ((libMSHE_gv_mMISNumberOfShrinesEvents > 0)) {

        UserDataSetInt("MapVOEvent", "Shrine Active", "Value", 1, 1);

    }

    else {

        UserDataSetInt("MapVOEvent", "Shrine Active First", "Value", 1, 1);

    }

    lv_groupAngel = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamOrderIndex_C, false);

    lv_groupDemon = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamChaosIndex_C, false);

    lv_groupObserver = libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer];

    ConversationDataLineSetPlayers("ShrinesVO", ("Angel"), lv_groupAngel);

    ConversationDataLineSetPlayers("ShrinesVO", ("Demon"), lv_groupDemon);

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

    libCore_gf_WaitForConversationToFinish();

    TriggerQueueExit();

    return true;

}



trigger auto_libMSHE_gf_MMISTransmissionPunisherSummoned_Trigger = null;

int auto_libMSHE_gf_MMISTransmissionPunisherSummoned_lp_team;

int auto_libMSHE_gf_MMISTransmissionPunisherSummoned_lp_shrineType;



void libMSHE_gf_MMISTransmissionPunisherSummoned (int lp_team, int lp_shrineType) {

    auto_libMSHE_gf_MMISTransmissionPunisherSummoned_lp_team = lp_team;

    auto_libMSHE_gf_MMISTransmissionPunisherSummoned_lp_shrineType = lp_shrineType;



    if (auto_libMSHE_gf_MMISTransmissionPunisherSummoned_Trigger == null) {

        auto_libMSHE_gf_MMISTransmissionPunisherSummoned_Trigger = TriggerCreate("auto_libMSHE_gf_MMISTransmissionPunisherSummoned_TriggerFunc");

    }



    TriggerExecute(auto_libMSHE_gf_MMISTransmissionPunisherSummoned_Trigger, false, false);

}



bool auto_libMSHE_gf_MMISTransmissionPunisherSummoned_TriggerFunc (bool testConds, bool runActions) {

    int lp_team = auto_libMSHE_gf_MMISTransmissionPunisherSummoned_lp_team;

    int lp_shrineType = auto_libMSHE_gf_MMISTransmissionPunisherSummoned_lp_shrineType;



    // Variable Declarations

    playergroup lv_groupAngel;

    playergroup lv_groupDemon;

    playergroup lv_groupObserver;

    int lv_itLineIndex;



    // Automatic Variable Declarations

    int autoE556D555_val;

    int auto3F72B5AC_val;



    // Variable Initialization

    lv_groupAngel = PlayerGroupEmpty();

    lv_groupDemon = PlayerGroupEmpty();

    lv_groupObserver = PlayerGroupEmpty();



    // Implementation

    if ((libGame_gv_gameOver == true)) {

        return true;

    }



    TriggerQueueEnter();

    UserDataResetType("MapVOEvent");

    ConversationDataLineResetPlayers("ShrinesVO", ("Angel"));

    ConversationDataLineResetPlayers("ShrinesVO", ("Demon"));

    ConversationDataLineResetPlayers("ShrinesVO", ("Observer"));

    if ((lp_team == libGame_gv_teamOrderIndex_C)) {

        auto3F72B5AC_val = lp_shrineType;

        if (auto3F72B5AC_val == libMSHE_ge_MMISShrineTypes_ArcaneShrine) {

            UserDataSetInt("MapVOEvent", "Allied Punisher Arcane", "Value", 1, 1);

            UserDataSetInt("MapVOEvent", "Observer Punisher Arcane Blue", "Value", 1, 1);

        }

        else if (auto3F72B5AC_val == libMSHE_ge_MMISShrineTypes_FrozenShrine) {

            UserDataSetInt("MapVOEvent", "Allied Punisher Frozen", "Value", 1, 1);

            UserDataSetInt("MapVOEvent", "Observer Punisher Frozen Blue", "Value", 1, 1);

        }

        else if (auto3F72B5AC_val == libMSHE_ge_MMISShrineTypes_BombardShrine) {

            UserDataSetInt("MapVOEvent", "Allied Punisher Mortar", "Value", 1, 1);

            UserDataSetInt("MapVOEvent", "Observer Punisher Mortar Blue", "Value", 1, 1);

        }

        else {

        }

    }

    else {

        autoE556D555_val = lp_shrineType;

        if (autoE556D555_val == libMSHE_ge_MMISShrineTypes_ArcaneShrine) {

            UserDataSetInt("MapVOEvent", "Enemy Punisher Arcane", "Value", 1, 1);

            UserDataSetInt("MapVOEvent", "Observer Punisher Arcane Red", "Value", 1, 1);

        }

        else if (autoE556D555_val == libMSHE_ge_MMISShrineTypes_FrozenShrine) {

            UserDataSetInt("MapVOEvent", "Enemy Punisher Frozen", "Value", 1, 1);

            UserDataSetInt("MapVOEvent", "Observer Punisher Frozen Red", "Value", 1, 1);

        }

        else if (autoE556D555_val == libMSHE_ge_MMISShrineTypes_BombardShrine) {

            UserDataSetInt("MapVOEvent", "Enemy Punisher Mortar", "Value", 1, 1);

            UserDataSetInt("MapVOEvent", "Observer Punisher Mortar Red", "Value", 1, 1);

        }

        else {

        }

    }

    lv_groupAngel = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamOrderIndex_C, false);

    lv_groupDemon = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamChaosIndex_C, false);

    lv_groupObserver = libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer];

    ConversationDataLineSetPlayers("ShrinesVO", ("Angel"), lv_groupAngel);

    ConversationDataLineSetPlayers("ShrinesVO", ("Demon"), lv_groupDemon);

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

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

    libCore_gf_WaitForConversationToFinish();

    TriggerQueueExit();

    return true;

}



trigger auto_libMSHE_gf_MMISTransmissionPunisherKilled_Trigger = null;

int auto_libMSHE_gf_MMISTransmissionPunisherKilled_lp_team;



void libMSHE_gf_MMISTransmissionPunisherKilled (int lp_team) {

    auto_libMSHE_gf_MMISTransmissionPunisherKilled_lp_team = lp_team;



    if (auto_libMSHE_gf_MMISTransmissionPunisherKilled_Trigger == null) {

        auto_libMSHE_gf_MMISTransmissionPunisherKilled_Trigger = TriggerCreate("auto_libMSHE_gf_MMISTransmissionPunisherKilled_TriggerFunc");

    }



    TriggerExecute(auto_libMSHE_gf_MMISTransmissionPunisherKilled_Trigger, false, false);

}



bool auto_libMSHE_gf_MMISTransmissionPunisherKilled_TriggerFunc (bool testConds, bool runActions) {

    int lp_team = auto_libMSHE_gf_MMISTransmissionPunisherKilled_lp_team;



    // Variable Declarations

    playergroup lv_groupAngel;

    playergroup lv_groupDemon;

    playergroup lv_groupObserver;

    int lv_itLineIndex;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_groupAngel = PlayerGroupEmpty();

    lv_groupDemon = PlayerGroupEmpty();

    lv_groupObserver = PlayerGroupEmpty();



    // Implementation

    if ((libGame_gv_gameOver == true)) {

        return true;

    }



    TriggerQueueEnter();

    UserDataResetType("MapVOEvent");

    ConversationDataLineResetPlayers("ShrinesVO", ("Angel"));

    ConversationDataLineResetPlayers("ShrinesVO", ("Demon"));

    ConversationDataLineResetPlayers("ShrinesVO", ("Observer"));

    if ((lp_team == libGame_gv_teamOrderIndex_C)) {

        if ((libMSHE_gv_mMISNumberOfShrinesEvents > 1)) {

            UserDataSetInt("MapVOEvent", "Allied Punisher Killed", "Value", 1, 1);

        }

        else {

            UserDataSetInt("MapVOEvent", "Allied Punisher Killed First", "Value", 1, 1);

        }

        UserDataSetInt("MapVOEvent", "Observer Punisher Killed Blue", "Value", 1, 1);

    }

    else {

        if ((libMSHE_gv_mMISNumberOfShrinesEvents > 1)) {

            UserDataSetInt("MapVOEvent", "Enemy Punisher Killed", "Value", 1, 1);

        }

        else {

            UserDataSetInt("MapVOEvent", "Enemy Punisher Killed First", "Value", 1, 1);

        }

        UserDataSetInt("MapVOEvent", "Observer Punisher Killed Red", "Value", 1, 1);

    }

    lv_groupAngel = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamOrderIndex_C, false);

    lv_groupDemon = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamChaosIndex_C, false);

    lv_groupObserver = libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer];

    ConversationDataLineSetPlayers("ShrinesVO", ("Angel"), lv_groupAngel);

    ConversationDataLineSetPlayers("ShrinesVO", ("Demon"), lv_groupDemon);

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

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

    libCore_gf_WaitForConversationToFinish();

    TriggerQueueExit();

    return true;

}



void libMSHE_gf_MMTowerPushUIShowHidePanel (bool lp_showHide) {

    // Automatic Variable Declarations

    // Implementation

    DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_mainPanel, libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroupNoNPCPlayers, lp_showHide);

    DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_mainPanel, libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroupNoNPCPlayers, lp_showHide);

    DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_mainPanel, libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer], lp_showHide);

}



void libMSHE_gf_MMTowerPushUISetGoblinCount (int lp_count, int lp_count2) {

    // Automatic Variable Declarations

    // Implementation

    TextExpressionSetToken("Param/Expression/lib_MSHE_7B0D17EF", "A", IntToText(lp_count));

    TextExpressionSetToken("Param/Expression/lib_MSHE_7B0D17EF", "B", IntToText(libMSHE_gv_mMDiabloShrineCursedEventTotal_C));

    libNtve_gf_SetDialogItemText(libMSHE_gv_mMTowerPushPanel.lv_hauntedMinesSkullModeSkullCounterLabel[1], TextExpressionAssemble("Param/Expression/lib_MSHE_7B0D17EF"), PlayerGroupAll());

    TextExpressionSetToken("Param/Expression/lib_MSHE_E44F01EB", "A", IntToText(lp_count2));

    TextExpressionSetToken("Param/Expression/lib_MSHE_E44F01EB", "B", IntToText(libMSHE_gv_mMDiabloShrineCursedEventTotal_C));

    libNtve_gf_SetDialogItemText(libMSHE_gv_mMTowerPushPanel.lv_hauntedMinesSkullModeSkullCounterLabel[2], TextExpressionAssemble("Param/Expression/lib_MSHE_E44F01EB"), PlayerGroupAll());

}



void libMSHE_gf_MMTowerPushUISetMode (int lp_mode) {

    // Automatic Variable Declarations

    int autoB3683D6E_val;



    // Implementation

    autoB3683D6E_val = lp_mode;

    if (autoB3683D6E_val == libMSHE_ge_MMISUIModes_Idle) {

        libMSHE_gf_MMTowerPushUIShowHidePanel(false);

    }

    else if (autoB3683D6E_val == libMSHE_ge_MMISUIModes_ShrineWarning) {

        libMSHE_gf_MMTowerPushUIShowHidePanel(true);

        DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_shrineWarningFrame, PlayerGroupAll(), true);

        DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_punisherFrame, PlayerGroupAll(), false);

        DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_hauntedMinesSkullModeFrame, PlayerGroupAll(), false);

        DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_shrineActiveFrame, PlayerGroupAll(), false);

    }

    else if (autoB3683D6E_val == libMSHE_ge_MMISUIModes_ShrineActive) {

        libMSHE_gf_MMTowerPushUIShowHidePanel(true);

        DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_shrineWarningFrame, PlayerGroupAll(), false);

        DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_punisherFrame, PlayerGroupAll(), false);

        DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_hauntedMinesSkullModeFrame, PlayerGroupAll(), false);

        DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_shrineActiveFrame, PlayerGroupAll(), true);

    }

    else if (autoB3683D6E_val == libMSHE_ge_MMISUIModes_Punisher) {

        libMSHE_gf_MMTowerPushUIShowHidePanel(true);

        DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_shrineWarningFrame, PlayerGroupAll(), false);

        DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_hauntedMinesSkullModeFrame, PlayerGroupAll(), false);

        DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_punisherFrame, PlayerGroupAll(), true);

        DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_shrineActiveFrame, PlayerGroupAll(), false);

    }

    else if (autoB3683D6E_val == libMSHE_ge_MMISUIModes_PunisherSpawning) {

        libMSHE_gf_MMTowerPushUIShowHidePanel(true);

        DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_shrineWarningFrame, PlayerGroupAll(), false);

        DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_hauntedMinesSkullModeFrame, PlayerGroupAll(), false);

        DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_punisherFrame, PlayerGroupAll(), true);

        DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_shrineActiveFrame, PlayerGroupAll(), false);

    }

    else if (autoB3683D6E_val == libMSHE_ge_MMISUIModes_CursedEvent) {

        libMSHE_gf_MMTowerPushUIShowHidePanel(true);

        DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_shrineWarningFrame, PlayerGroupAll(), false);

        DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_punisherFrame, PlayerGroupAll(), false);

        DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_hauntedMinesSkullModeFrame, PlayerGroupAll(), true);

        DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_shrineActiveFrame, PlayerGroupAll(), false);

    }

    else {

    }

}



void libMSHE_gf_MMTowerPushUISetEnergyGlobalProgressUnit3 (int lp_progressUnit) {

    // Automatic Variable Declarations

    // Implementation

    libNtve_gf_SetDialogItemText(libMSHE_gv_mMTowerPushPanel.lv_shrineWarningTimerLabel, TextTimeFormat(StringToText("<min2/>:<sec2/>"), lp_progressUnit), PlayerGroupAll());

}



void libMSHE_gf_MMTowerPushUISetEnergyGlobalProgressUnit5 (int lp_progressUnit) {

    // Automatic Variable Declarations

    // Implementation

    libNtve_gf_SetDialogItemText(libMSHE_gv_mMTowerPushPanel.lv_punisherTimer, TextTimeFormat(StringToText("<min2/>:<sec2/>"), lp_progressUnit), PlayerGroupAll());

}



void libMSHE_gf_MMTowerPushUISetEnergyGlobalProgressUnit (unit lp_progressUnit) {

    // Automatic Variable Declarations

    // Implementation

    libNtve_gf_SetDialogItemUnit(libMSHE_gv_mMTowerPushPanel.lv_punisherHealthBar, libMSHE_gv_mMISPunisher, PlayerGroupAll());

}



void libMSHE_gf_MMTowerPushUIInit (int lp_parentPanel) {

    int init_i;



    // Variable Declarations

    int[6] lv_panels;

    int lv_currentPanelLayer;

    int lv_itTeam;

    int lv_enemyTeam;



    // Automatic Variable Declarations

    const int autoC0AE2731_ae = libCore_gv_bALMaxTeams;

    const int autoC0AE2731_ai = 1;



    // Variable Initialization

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

        lv_panels[init_i] = c_invalidDialogControlId;

    }



    // Implementation

    DialogControlCreateInPanelFromTemplate(lp_parentPanel, c_triggerControlTypePanel, "Shrines/ShrinesPanel");

    DialogControlSetVisible(DialogControlLastCreated(), PlayerGroupAll(), false);

    lv_currentPanelLayer += 1;

    lv_panels[lv_currentPanelLayer] = DialogControlLastCreated();

    libMSHE_gv_mMTowerPushPanel.lv_mainPanel = DialogControlLastCreated();

    DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypePanel, "ShrineWarningFrame");

    DialogControlSetVisible(DialogControlLastCreated(), PlayerGroupAll(), false);

    lv_currentPanelLayer += 1;

    lv_panels[lv_currentPanelLayer] = DialogControlLastCreated();

    libMSHE_gv_mMTowerPushPanel.lv_shrineWarningFrame = DialogControlLastCreated();

    DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypeLabel, "ShrineWarningInfoLabel");

    libMSHE_gv_mMTowerPushPanel.lv_shrineWarningInfoLabel = DialogControlLastCreated();

    libNtve_gf_SetDialogItemText(DialogControlLastCreated(), StringExternal("Param/Value/lib_MSHE_BF00F160"), PlayerGroupAll());

    DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypeLabel, "ShrineWarningTimerLabel");

    libMSHE_gv_mMTowerPushPanel.lv_shrineWarningTimerLabel = DialogControlLastCreated();

    lv_currentPanelLayer -= 1;

    DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypePanel, "ShrineActiveFrame");

    DialogControlSetVisible(DialogControlLastCreated(), PlayerGroupAll(), false);

    lv_currentPanelLayer += 1;

    lv_panels[lv_currentPanelLayer] = DialogControlLastCreated();

    libMSHE_gv_mMTowerPushPanel.lv_shrineActiveFrame = DialogControlLastCreated();

    DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypeLabel, "ShrineActiveInfoLabel");

    libMSHE_gv_mMTowerPushPanel.lv_shrineActiveInfoLabel = DialogControlLastCreated();

    libNtve_gf_SetDialogItemText(DialogControlLastCreated(), StringExternal("Param/Value/lib_MSHE_37BAA147"), PlayerGroupAll());

    lv_currentPanelLayer -= 1;

    DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypePanel, "CursedMinionKillFrame");

    DialogControlSetVisible(DialogControlLastCreated(), PlayerGroupAll(), false);

    lv_currentPanelLayer += 1;

    lv_panels[lv_currentPanelLayer] = DialogControlLastCreated();

    libMSHE_gv_mMTowerPushPanel.lv_hauntedMinesSkullModeFrame = DialogControlLastCreated();

    lv_itTeam = 1;

    for ( ; ( (autoC0AE2731_ai >= 0 && lv_itTeam <= autoC0AE2731_ae) || (autoC0AE2731_ai < 0 && lv_itTeam >= autoC0AE2731_ae) ) ; lv_itTeam += autoC0AE2731_ai ) {

        lv_enemyTeam = libGame_gf_EnemyTeam(lv_itTeam);

        DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypeImage, "Team" + IntToString(lv_itTeam) + "BackgroundBlue");

        DialogControlSetVisible(DialogControlLastCreated(), libGame_gv_teams[lv_enemyTeam].lv_teamPlayerGroupNoNPCPlayers, false);

        if ((lv_itTeam == libGame_gv_teamChaosIndex_C)) {

            DialogControlSetVisible(DialogControlLastCreated(), libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer], false);

        }



        DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypeImage, "Team" + IntToString(lv_itTeam) + "SkullBlue");

        DialogControlSetVisible(DialogControlLastCreated(), libGame_gv_teams[lv_enemyTeam].lv_teamPlayerGroupNoNPCPlayers, false);

        if ((lv_itTeam == libGame_gv_teamChaosIndex_C)) {

            DialogControlSetVisible(DialogControlLastCreated(), libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer], false);

        }



        DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypeImage, "Team" + IntToString(lv_itTeam) + "BackgroundRed");

        DialogControlSetVisible(DialogControlLastCreated(), libGame_gv_teams[lv_itTeam].lv_teamPlayerGroupNoNPCPlayers, false);

        if ((lv_itTeam == libGame_gv_teamOrderIndex_C)) {

            DialogControlSetVisible(DialogControlLastCreated(), libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer], false);

        }



        DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypeImage, "Team" + IntToString(lv_itTeam) + "SkullRed");

        DialogControlSetVisible(DialogControlLastCreated(), libGame_gv_teams[lv_itTeam].lv_teamPlayerGroupNoNPCPlayers, false);

        if ((lv_itTeam == libGame_gv_teamOrderIndex_C)) {

            DialogControlSetVisible(DialogControlLastCreated(), libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer], false);

        }



        DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypeLabel, "Team" + IntToString(lv_itTeam) + "SkullCounter");

        if ((lv_itTeam == libGame_gv_teamOrderIndex_C)) {

            libNtve_gf_SetDialogItemStyle(DialogControlLastCreated(), "Storm_MapMechanic_MechanicCounterLeft_Blue", libGame_gv_teams[lv_itTeam].lv_teamPlayerGroupNoNPCPlayers);

            libNtve_gf_SetDialogItemStyle(DialogControlLastCreated(), "Storm_MapMechanic_MechanicCounterLeft_Red", libGame_gv_teams[lv_enemyTeam].lv_teamPlayerGroupNoNPCPlayers);

        }

        else {

            libNtve_gf_SetDialogItemStyle(DialogControlLastCreated(), "Storm_MapMechanic_MechanicCounterRight_Blue", libGame_gv_teams[lv_itTeam].lv_teamPlayerGroupNoNPCPlayers);

            libNtve_gf_SetDialogItemStyle(DialogControlLastCreated(), "Storm_MapMechanic_MechanicCounterRight_Red", libGame_gv_teams[lv_enemyTeam].lv_teamPlayerGroupNoNPCPlayers);

        }

        libMSHE_gv_mMTowerPushPanel.lv_hauntedMinesSkullModeSkullCounterLabel[lv_itTeam] = DialogControlLastCreated();

    }

    DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypePanel, "CrystalArcaneImage");

    DialogControlSetVisible(DialogControlLastCreated(), PlayerGroupAll(), false);

    libMSHE_gv_mMTowerPushPanel.lv_crystalArcaneIcon = DialogControlLastCreated();

    DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypePanel, "CrystalMortarImage");

    DialogControlSetVisible(DialogControlLastCreated(), PlayerGroupAll(), false);

    libMSHE_gv_mMTowerPushPanel.lv_crystalMortarIcon = DialogControlLastCreated();

    DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypePanel, "CrystalFrozenImage");

    DialogControlSetVisible(DialogControlLastCreated(), PlayerGroupAll(), false);

    libMSHE_gv_mMTowerPushPanel.lv_crystalFrozenIcon = DialogControlLastCreated();

    lv_currentPanelLayer -= 1;

    DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypePanel, "PunisherFrame");

    DialogControlSetVisible(DialogControlLastCreated(), PlayerGroupAll(), false);

    lv_currentPanelLayer += 1;

    lv_panels[lv_currentPanelLayer] = DialogControlLastCreated();

    libMSHE_gv_mMTowerPushPanel.lv_punisherFrame = DialogControlLastCreated();

    DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypeLabel, "PunisherInfoLabel");

    libMSHE_gv_mMTowerPushPanel.lv_punisherInfoLabel = DialogControlLastCreated();

    DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypeUnitStatus, "PunisherHealthBar");

    libMSHE_gv_mMTowerPushPanel.lv_punisherHealthBar = DialogControlLastCreated();

    DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypePanel, "PunisherArcaneAlly");

    libMSHE_gv_mMTowerPushPanel.lv_punisherArcaneAllyIcon = DialogControlLastCreated();

    DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypePanel, "PunisherArcaneEnemy");

    libMSHE_gv_mMTowerPushPanel.lv_punisherArcaneEnemyIcon = DialogControlLastCreated();

    DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypePanel, "PunisherFrozenAlly");

    libMSHE_gv_mMTowerPushPanel.lv_punisherFrozenAllyIcon = DialogControlLastCreated();

    DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypePanel, "PunisherFrozenEnemy");

    libMSHE_gv_mMTowerPushPanel.lv_punisherFrozenEnemyIcon = DialogControlLastCreated();

    DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypePanel, "PunisherMortarAlly");

    libMSHE_gv_mMTowerPushPanel.lv_punisherMortarAllyIcon = DialogControlLastCreated();

    DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypePanel, "PunisherMortarEnemy");

    libMSHE_gv_mMTowerPushPanel.lv_punisherMortarEnemyIcon = DialogControlLastCreated();

}



trigger auto_libMSHE_gf_MMISUIPunisherSpawnTimer_Trigger = null;

int auto_libMSHE_gf_MMISUIPunisherSpawnTimer_lp_team;



void libMSHE_gf_MMISUIPunisherSpawnTimer (int lp_team) {

    auto_libMSHE_gf_MMISUIPunisherSpawnTimer_lp_team = lp_team;



    if (auto_libMSHE_gf_MMISUIPunisherSpawnTimer_Trigger == null) {

        auto_libMSHE_gf_MMISUIPunisherSpawnTimer_Trigger = TriggerCreate("auto_libMSHE_gf_MMISUIPunisherSpawnTimer_TriggerFunc");

    }



    TriggerExecute(auto_libMSHE_gf_MMISUIPunisherSpawnTimer_Trigger, false, false);

}



bool auto_libMSHE_gf_MMISUIPunisherSpawnTimer_TriggerFunc (bool testConds, bool runActions) {

    int lp_team = auto_libMSHE_gf_MMISUIPunisherSpawnTimer_lp_team;



    // Variable Declarations

    fixed lv_life;



    // Automatic Variable Declarations

    // Variable Initialization



    // Implementation

    libNtve_gf_CreateUnitsWithDefaultFacing(1, "JungleCampIconUnit", c_unitCreateIgnorePlacement, libGame_gf_ComputerPlayerInTeam(lp_team), Point(0.0, 0.0), null);

    libMSHE_gv_mMISPunisher = UnitLastCreated();

    libNtve_gf_ShowHideUnit(UnitLastCreated(), false);

    libNtve_gf_MakeUnitInvulnerable(UnitLastCreated(), true);

    libNtve_gf_PauseUnit(UnitLastCreated(), true);

    libNtve_gf_SendActorMessageToUnit(UnitLastCreated(), "SetMinimapVisibility");

    libNtve_gf_SendActorMessageToUnit(UnitLastCreated(), "SetMinimapVisibilityAlways");

    UnitSetState(UnitLastCreated(), c_unitStateTargetable, false);

    UnitSetState(UnitLastCreated(), c_unitStateRadarable, false);

    UnitSetState(UnitLastCreated(), c_unitStateStatusBar, false);

    UnitSetState(UnitLastCreated(), c_unitStateSelectable, false);

    UnitSetState(UnitLastCreated(), c_unitStateHighlightable, false);

    UnitSetState(UnitLastCreated(), c_unitStateDetectable, false);

    UnitSetState(UnitLastCreated(), c_unitStateCursorable, false);

    UnitSetPropertyFixed(UnitLastCreated(), c_unitPropLifeMax, 100.0);

    UnitSetPropertyFixed(UnitLastCreated(), c_unitPropLife, 1.0);

    libMSHE_gf_MMTowerPushUISetEnergyGlobalProgressUnit(UnitLastCreated());

    while (true) {

        if ((TimerGetRemaining(libMSHE_gv_mMISPunisherSpawnTimer) <= 0.0)) {

            Wait(1.0, c_timeGame);

            UnitRemove(UnitLastCreated());

            return true;

        }

        else {

            lv_life += 1.835;

            UnitSetPropertyFixed(libMSHE_gv_mMISPunisher, c_unitPropLife, lv_life);

        }

        Wait(0.0625, c_timeGame);

    }

    return true;

}



// Triggers

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

// Trigger: MM IS Init

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

bool libMSHE_gt_MMISInit_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_itPlayer;



    // Automatic Variable Declarations

    const int auto85598028_ae = libCore_gv_bALMaxPlayers;

    const int auto85598028_ai = 1;



    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libGame_gf_MapMechanicInitializationMechanicType() == libMSHE_gv_mMISMechanicName_C))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    TriggerExecute(libMLHH_gt_IncludeHH, true, false);

    lv_itPlayer = 1;

    for ( ; ( (auto85598028_ai >= 0 && lv_itPlayer <= auto85598028_ae) || (auto85598028_ai < 0 && lv_itPlayer >= auto85598028_ae) ) ; lv_itPlayer += auto85598028_ai ) {

        CatalogFieldValueSet(c_gameCatalogEffect, "CaptureMacGuffin", "PeriodCount", lv_itPlayer, "1");

        CatalogFieldValueSet(c_gameCatalogEffect, "CaptureMacGuffin", "PeriodicPeriodArray[" + IntToString(0) + "]", lv_itPlayer, "0");

    }

    libGame_gf_SendMapSpecificAwardInitializeEventwithUserData(null, "Generic Instance");

    TriggerExecute(libMSHE_gt_MMISInitializeShrines, true, false);

    return true;

}



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

void libMSHE_gt_MMISInit_Init () {

    libMSHE_gt_MMISInit = TriggerCreate("libMSHE_gt_MMISInit_Func");

    libGame_gf_MapMechanicInitialization(libMSHE_gt_MMISInit);

}



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

// Trigger: MM IS Ping Data Init

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

bool libMSHE_gt_MMISPingDataInit_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Actions

    if (!runActions) {

        return true;

    }



    libUIUI_gf_PingCreateNewPingTarget("DiabloShrineWarningUnit", false, null, StringExternal("Param/Value/lib_MSHE_02783CD4"), StringExternal("Param/Value/lib_MSHE_22894A5E"), SoundLink("UI_Game_Ping_Help", -1), SoundLink("UI_Game_Ping_Attack", -1));

    libUIUI_gf_PingCreateNewPingTarget("DiabloShrine", false, null, StringExternal("Param/Value/lib_MSHE_D9D04C20"), StringExternal("Param/Value/lib_MSHE_7E4B3496"), SoundLink("UI_Game_Ping_Help", -1), SoundLink("UI_Game_Ping_Attack", -1));

    libUIUI_gf_PingCreateNewPingTarget("MercPunisherLaner", false, null, StringExternal("Param/Value/lib_MSHE_1A30E150"), StringExternal("Param/Value/lib_MSHE_EA97B1A0"), SoundLink("UI_Game_Ping_Help", -1), SoundLink("UI_Game_Ping_Attack", -1));

    return true;

}



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

void libMSHE_gt_MMISPingDataInit_Init () {

    libMSHE_gt_MMISPingDataInit = TriggerCreate("libMSHE_gt_MMISPingDataInit_Func");

    libCore_gf_IncludeModInitialization(libMSHE_gt_MMISPingDataInit);

}



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

// Trigger: MM IS Gate Open

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

bool libMSHE_gt_MMISGateOpen_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_itTeam;

    int lv_teamEnemy;

    playergroup lv_playersAlly;

    playergroup lv_playersEnemy;

    int lv_itPlayer;

    unit lv_itHero;

    int lv_itSoulCage;

    int lv_itShrine;



    // Automatic Variable Declarations

    int autoD4036543_ae;

    const int autoD4036543_ai = 1;



    // Variable Initialization

    lv_playersAlly = PlayerGroupEmpty();

    lv_playersEnemy = PlayerGroupEmpty();



    // Conditions

    if (testConds) {

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

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    TriggerExecute(libMSHE_gt_MMISUIHandler, true, false);

    TimerStart(libMSHE_gv_mMISShrineTimer, libMSHE_gv_mMDiabloShrinesShrineTimerDuration_C, false, c_timeGame);

    TimerStart(libMSHE_gv_mMISExperince, libMSHE_gv_mMDiabloShrinesExperinceTimer_C, false, c_timeGame);

    TimerStart(libMSHE_gv_mMISAffixTimer, libMSHE_gv_mMISAffixTimerDuration, false, c_timeGame);

    libMSHE_gv_mMDiabloShrinesShrineTimerWarning = libMSHE_gv_mMDiabloShrineWarningTimerLong_C;

    CatalogFieldValueSet(c_gameCatalogBehavior, "DiabloShrineWarningFX", "Duration", libCore_gv_cOMPUTER_Neutral, IntToString(FixedToInt(libMSHE_gv_mMDiabloShrineWarningTimerLong_C)));

    autoD4036543_ae = libMSHE_gv_mMISNumberofShrinesAllowed;

    lv_itShrine = 1;

    for ( ; ( (autoD4036543_ai >= 0 && lv_itShrine <= autoD4036543_ae) || (autoD4036543_ai < 0 && lv_itShrine >= autoD4036543_ae) ) ; lv_itShrine += autoD4036543_ai ) {

        libNtve_gf_SendActorMessageToUnit(libMSHE_gv_mMISShrines[lv_itShrine], "Signal LongIntro");

    }

    TimerStart(libMSHE_gv_mMISObjectivePreviewTimer, libMSHE_gv_mMISObjectivePreviewDelay_C, false, c_timeGame);

    return true;

}



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

void libMSHE_gt_MMISGateOpen_Init () {

    libMSHE_gt_MMISGateOpen = TriggerCreate("libMSHE_gt_MMISGateOpen_Func");

    TriggerAddEventTimer(libMSHE_gt_MMISGateOpen, libGame_gv_openTheGatesTimer);

}



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

// Trigger: MMIS Warning Timer Long

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

bool libMSHE_gt_MMISWarningTimerLong_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_itShrine;



    // Automatic Variable Declarations

    int auto21D321F8_ae;

    const int auto21D321F8_ai = 1;



    // Variable Initialization



    // Actions

    if (!runActions) {

        return true;

    }



    libMSHE_gv_mMDiabloShrinesShrineTimerWarning = libMSHE_gv_mMDiabloShrineWarningTimerLong_C;

    CatalogFieldValueSet(c_gameCatalogBehavior, "DiabloShrineWarningFX", "Duration", libCore_gv_cOMPUTER_Neutral, IntToString(FixedToInt(libMSHE_gv_mMDiabloShrineWarningTimerLong_C)));

    auto21D321F8_ae = libMSHE_gv_mMISNumberofShrinesAllowed;

    lv_itShrine = 1;

    for ( ; ( (auto21D321F8_ai >= 0 && lv_itShrine <= auto21D321F8_ae) || (auto21D321F8_ai < 0 && lv_itShrine >= auto21D321F8_ae) ) ; lv_itShrine += auto21D321F8_ai ) {

        libNtve_gf_SendActorMessageToUnit(libMSHE_gv_mMISShrines[lv_itShrine], "Signal LongIntro");

    }

    return true;

}



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

void libMSHE_gt_MMISWarningTimerLong_Init () {

    libMSHE_gt_MMISWarningTimerLong = TriggerCreate("libMSHE_gt_MMISWarningTimerLong_Func");

    TriggerAddEventTimer(libMSHE_gt_MMISWarningTimerLong, libMSHE_gv_mMISLongWarningTimer);

}



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

// Trigger: MM IS Cursed Event Minion Tracker

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

bool libMSHE_gt_MMISCursedEventMinionTracker_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((UnitGetType(EventUnitCreatedUnit()) == "CursedShrineMinion"))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    UnitSetOwner(EventUnitCreatedUnit(), 15, true);

    UnitXPAddXP(EventUnitCreatedUnit(), null, libMSHE_gv_mMISMonsterXP);

    UnitGroupAdd(libMSHE_gv_mMISCursedCreatures, EventUnitCreatedUnit());

    return true;

}



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

void libMSHE_gt_MMISCursedEventMinionTracker_Init () {

    libMSHE_gt_MMISCursedEventMinionTracker = TriggerCreate("libMSHE_gt_MMISCursedEventMinionTracker_Func");

    TriggerEnable(libMSHE_gt_MMISCursedEventMinionTracker, false);

    TriggerAddEventUnitCreated(libMSHE_gt_MMISCursedEventMinionTracker, null, "CursedShrineSpawn", null);

}



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

// Trigger: MM IS Cursed Event Score Tracker

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

bool libMSHE_gt_MMISCursedEventScoreTracker_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_itKill;

    unit lv_shrine;

    string lv_shrineBuff;

    int lv_itPlayer;

    int lv_winningTeam;

    playergroup lv_textTagPlayers;

    playergroup lv_enemyTextTagPlayers;

    unit lv_bannerSconceUnit;



    // Automatic Variable Declarations

    unitgroup autoD5FE4C8D_g;

    int autoD5FE4C8D_u;

    unitgroup autoCEE0C33A_g;

    int autoCEE0C33A_u;

    unitgroup autoDA0B9F3E_g;

    int autoDA0B9F3E_u;

    unit autoDA0B9F3E_var;



    // Variable Initialization

    lv_textTagPlayers = PlayerGroupEmpty();

    lv_enemyTextTagPlayers = PlayerGroupEmpty();



    // Conditions

    if (testConds) {

        if (!((UnitGetType(EventUnit()) == "CursedShrineMinion"))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libMSHE_gv_mMISKillCount[libGame_gf_TeamNumberOfPlayer(libNtve_gf_KillingPlayer())] += 1;

    lv_textTagPlayers = libGame_gf_AlliedPlayerGroupOfPlayer(libNtve_gf_KillingPlayer());

    lv_enemyTextTagPlayers = libGame_gf_EnemyPlayerGroupOfPlayer(libNtve_gf_KillingPlayer());

    if ((libGame_gf_TeamNumberOfPlayer(libNtve_gf_KillingPlayer()) == libGame_gv_teamOrderIndex_C)) {

        PlayerGroupAdd(lv_textTagPlayers, libCore_gv_oBSERVER_ObserverUIPlayer);

    }

    else {

        PlayerGroupAdd(lv_enemyTextTagPlayers, libCore_gv_oBSERVER_ObserverUIPlayer);

    }

    TextExpressionSetToken("Param/Expression/lib_MSHE_034712A9", "A", IntToText(1));

    TextTagCreate(TextExpressionAssemble("Param/Expression/lib_MSHE_034712A9"), 24, UnitGetPosition(EventUnit()), 1.0, true, true, lv_textTagPlayers);

    TextTagSetVelocity(TextTagLastCreated(), 1.5, 90.0);

    TextTagSetTime(TextTagLastCreated(), c_textTagTimeDuration, 3.0);

    TextTagSetFogVisibility(TextTagLastCreated(), c_visTypeFog);

    TextExpressionSetToken("Param/Expression/lib_MSHE_A99E643F", "A", IntToText(1));

    TextTagCreate(TextExpressionAssemble("Param/Expression/lib_MSHE_A99E643F"), 24, UnitGetPosition(EventUnit()), 1.0, true, true, lv_enemyTextTagPlayers);

    TextTagSetVelocity(TextTagLastCreated(), 1.5, 90.0);

    TextTagSetTime(TextTagLastCreated(), c_textTagTimeDuration, 3.0);

    TextTagSetFogVisibility(TextTagLastCreated(), c_visTypeFog);

    libMSHE_gf_MMISTextTagScoreHandler((3 - libGame_gf_TeamNumberOfPlayer(libNtve_gf_KillingPlayer())), libGame_gf_TeamNumberOfPlayer(libNtve_gf_KillingPlayer()), libMSHE_gv_mMISShrines[libMSHE_gv_mMISCurrentShrine]);

    if ((libMSHE_gv_mMISKillCount[libGame_gf_TeamNumberOfPlayer(libNtve_gf_KillingPlayer())] == libMSHE_gv_mMDiabloShrineCursedEventTotal_C)) {

        lv_shrine = libMSHE_gv_mMISShrines[libMSHE_gv_mMISCurrentShrine];

        lv_winningTeam = libGame_gf_TeamNumberOfPlayer(libNtve_gf_KillingPlayer());

        if ((UnitHasBehavior2(lv_shrine, "CombatShrine") == true)) {

            lv_shrineBuff = "CombatShrineBuff";

            libMSHE_gv_mMISShrineBuffText = StringExternal("Param/Value/lib_MSHE_6F731C56");

            libMSHE_gf_MMISAnnouncementShrineCaptured(lv_shrine, libMSHE_ge_MMISShrineTypes_CombatShrine, lv_winningTeam);

        }



        if ((UnitHasBehavior2(lv_shrine, "SiegeShrine") == true)) {

            lv_shrineBuff = "SiegeShrineBuff";

            libMSHE_gv_mMISShrineBuffText = StringExternal("Param/Value/lib_MSHE_DA4BAFA0");

            libMSHE_gf_MMISAnnouncementShrineCaptured(lv_shrine, libMSHE_ge_MMISShrineTypes_SiegeShrine, lv_winningTeam);

        }



        if ((UnitHasBehavior2(lv_shrine, "MonsterShrine") == true)) {

            libMSHE_gf_MMISAnnouncementShrineCaptured(lv_shrine, libMSHE_ge_MMISShrineTypes_MonsterShrine, lv_winningTeam);

        }



        if ((UnitHasBehavior2(lv_shrine, "ThunderstormShrine") == true)) {

            lv_shrineBuff = "ThunderstormShrineBuff";

            libMSHE_gv_mMISShrineBuffText = StringExternal("Param/Value/lib_MSHE_C5ED68F5");

            libMSHE_gf_MMISAnnouncementShrineCaptured(lv_shrine, libMSHE_ge_MMISShrineTypes_ThunderstormShrine, lv_winningTeam);

        }



        if ((UnitHasBehavior2(lv_shrine, "FrozenShrine") == true)) {

            lv_shrineBuff = "FrozenShrineBuff";

            libMSHE_gv_mMISShrineBuffText = StringExternal("Param/Value/lib_MSHE_A5510C71");

            libMSHE_gf_MMISAnnouncementShrineCaptured(lv_shrine, libMSHE_ge_MMISShrineTypes_FrozenShrine, lv_winningTeam);

        }



        if ((UnitHasBehavior2(lv_shrine, "BombardShrine") == true)) {

            lv_shrineBuff = "BombardShrineBuff";

            libMSHE_gv_mMISShrineBuffText = StringExternal("Param/Value/lib_MSHE_3352DCC5");

            libMSHE_gf_MMISAnnouncementShrineCaptured(lv_shrine, libMSHE_ge_MMISShrineTypes_BombardShrine, lv_winningTeam);

        }



        if ((UnitHasBehavior2(lv_shrine, "ArcaneShrine") == true)) {

            lv_shrineBuff = "ArcaneShrineBuff";

            libMSHE_gv_mMISShrineBuffText = StringExternal("Param/Value/lib_MSHE_97D2F91E");

            libMSHE_gf_MMISAnnouncementShrineCaptured(lv_shrine, libMSHE_ge_MMISShrineTypes_ArcaneShrine, lv_winningTeam);

        }



        RemoveUnitOfInterest(libMSHE_gv_mMISShrines[libMSHE_gv_mMISCurrentShrine], "FightAtShrine", libNtve_ge_GoalTeam_Both);

        libMSHE_gf_MMISGrantShrineRewardToTeam(lv_winningTeam, lv_shrine, lv_shrineBuff);

        libGame_gf_SendEventMapObjectiveCapturedByUnit(libNtve_gf_KillingUnit());

        autoD5FE4C8D_g = UnitGroup("LootBannerSconce", c_playerAny, RegionCircle(UnitGetPosition(lv_shrine), 10.0), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 2);

        autoD5FE4C8D_u = UnitGroupCount(autoD5FE4C8D_g, c_unitCountAll);

        for (;; autoD5FE4C8D_u -= 1) {

            lv_bannerSconceUnit = UnitGroupUnitFromEnd(autoD5FE4C8D_g, autoD5FE4C8D_u);

            if (lv_bannerSconceUnit == null) { break; }

            libGame_gf_DropLootBannerinSconce(lv_bannerSconceUnit, libGame_gv_players[libNtve_gf_KillingPlayer()].lv_lootContent.lv_loot_Banner.lv_bannerID, libNtve_gf_KillingPlayer(), true);

        }

        StatEventCreate("Infernal Shrine Captured");

        StatEventAddDataInt(StatEventLastCreated(), "Event", libMSHE_gv_mMISNumberOfShrinesEvents);

        StatEventAddDataInt(StatEventLastCreated(), "Winning Team", lv_winningTeam);

        StatEventAddDataInt(StatEventLastCreated(), "Winning Score", libMSHE_gv_mMISKillCount[lv_winningTeam]);

        StatEventAddDataInt(StatEventLastCreated(), "Losing Score", libMSHE_gv_mMISKillCount[libGame_gf_EnemyTeam(lv_winningTeam)]);

        StatEventAddDataFixed(StatEventLastCreated(), "GameTime", libUIUI_gf_HeroesGameTime());

        StatEventSend(StatEventLastCreated());

        libMSHE_gv_mMISKillCount[libGame_gv_teamOrderIndex_C] = 0;

        libMSHE_gv_mMISKillCount[libGame_gv_teamChaosIndex_C] = 0;

        libMSHE_gv_mMISCursedEvent = false;

        TriggerEnable(libMSHE_gt_MMISCursedEventScoreTracker, false);

        TriggerEnable(libMSHE_gt_MMISCursedEventTimerRespawner, false);

        TriggerEnable(libMSHE_gt_MMISCursedEventMinionTracker, false);

        Wait(0.125, c_timeGame);

        autoCEE0C33A_g = libMSHE_gv_mMISCursedCreatures;

        autoCEE0C33A_u = UnitGroupCount(autoCEE0C33A_g, c_unitCountAll);

        for (;; autoCEE0C33A_u -= 1) {

            lv_itKill = UnitGroupUnitFromEnd(autoCEE0C33A_g, autoCEE0C33A_u);

            if (lv_itKill == null) { break; }

            UnitRemove(lv_itKill);

        }

        autoDA0B9F3E_g = UnitGroup("CursedShrineMinion", c_playerAny, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);

        autoDA0B9F3E_u = UnitGroupCount(autoDA0B9F3E_g, c_unitCountAll);

        for (;; autoDA0B9F3E_u -= 1) {

            autoDA0B9F3E_var = UnitGroupUnitFromEnd(autoDA0B9F3E_g, autoDA0B9F3E_u);

            if (autoDA0B9F3E_var == null) { break; }

            UnitRemove(autoDA0B9F3E_var);

        }

    }



    return true;

}



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

void libMSHE_gt_MMISCursedEventScoreTracker_Init () {

    libMSHE_gt_MMISCursedEventScoreTracker = TriggerCreate("libMSHE_gt_MMISCursedEventScoreTracker_Func");

    TriggerEnable(libMSHE_gt_MMISCursedEventScoreTracker, false);

    TriggerAddEventUnitDied(libMSHE_gt_MMISCursedEventScoreTracker, null);

}



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

// Trigger: MM IS Cursed Event Timer Respawner

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

bool libMSHE_gt_MMISCursedEventTimerRespawner_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    int auto82D5C579_n;

    int auto82D5C579_i;



    // Conditions

    if (testConds) {

        if (!((EventTimer() == libMSHE_gv_mMISCursedRefreshTimer))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if (((libMSHE_gv_mMISTotalMonsters_C - UnitGroupCount(libMSHE_gv_mMISCursedCreatures, c_unitCountAlive)) > 0)) {

        auto82D5C579_n = (libMSHE_gv_mMISTotalMonsters_C - UnitGroupCount(libMSHE_gv_mMISCursedCreatures, c_unitCountAlive));

        for (auto82D5C579_i = 1; auto82D5C579_i <= auto82D5C579_n; auto82D5C579_i += 1) {

            if ((libMSHE_gv_mMISCursedEvent == true)) {

                UnitIssueOrder(libMSHE_gv_mMISShrines[libMSHE_gv_mMISCurrentShrine], OrderTargetingPoint(AbilityCommand("CursedShrineSpawn", 0), RegionRandomPoint(libMSHE_gv_mMISRegions[libMSHE_gv_mMISCurrentShrine])), c_orderQueueReplace);

                Wait(0.15, c_timeGame);

            }



        }

    }



    TimerStart(libMSHE_gv_mMISCursedRefreshTimer, libMSHE_gv_mMDiabloShrineRefreshMonster_C, false, c_timeGame);

    return true;

}



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

void libMSHE_gt_MMISCursedEventTimerRespawner_Init () {

    libMSHE_gt_MMISCursedEventTimerRespawner = TriggerCreate("libMSHE_gt_MMISCursedEventTimerRespawner_Func");

    TriggerEnable(libMSHE_gt_MMISCursedEventTimerRespawner, false);

    TriggerAddEventTimer(libMSHE_gt_MMISCursedEventTimerRespawner, null);

}



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

// Trigger: MM IS Cursed Event Minion Damage Tracker

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

bool libMSHE_gt_MMISCursedEventMinionDamageTracker_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((UnitGetType(EventUnit()) == "CursedShrineMinion"))) {

            return false;

        }



        if (!(((EventUnitDamageSourcePlayer() >= 1) && (EventUnitDamageSourcePlayer() <= libCore_gv_bALMaxPlayers)))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libMSHE_gv_mMISDamageDoneToShrineMinions[EventUnitDamageSourcePlayer()] += FixedToInt(EventUnitDamageAmount());

    libGame_gf_SendMapSpecificAwardEvent(EventUnitDamageSourcePlayer(), EventUnitDamageAmount(), true);

    return true;

}



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

void libMSHE_gt_MMISCursedEventMinionDamageTracker_Init () {

    libMSHE_gt_MMISCursedEventMinionDamageTracker = TriggerCreate("libMSHE_gt_MMISCursedEventMinionDamageTracker_Func");

    TriggerAddEventUnitDamaged(libMSHE_gt_MMISCursedEventMinionDamageTracker, null, c_unitDamageTypeAny, c_unitDamageEither, null);

}



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

// Trigger: MM IS Experience Timer Expired

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

bool libMSHE_gt_MMISExperienceTimerExpired_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Actions

    if (!runActions) {

        return true;

    }



    libMSHE_gv_mMISMonsterXP += 1.0;

    TimerStart(libMSHE_gv_mMISExperince, libMSHE_gv_mMDiabloShrinesExperinceTimer_C, false, c_timeGame);

    return true;

}



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

void libMSHE_gt_MMISExperienceTimerExpired_Init () {

    libMSHE_gt_MMISExperienceTimerExpired = TriggerCreate("libMSHE_gt_MMISExperienceTimerExpired_Func");

    TriggerAddEventTimer(libMSHE_gt_MMISExperienceTimerExpired, libMSHE_gv_mMISExperince);

}



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

// Trigger: MM IS Initialize Shrines

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

bool libMSHE_gt_MMISInitializeShrines_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_u;



    // Automatic Variable Declarations

    unitgroup auto6249E76F_g;

    int auto6249E76F_u;



    // Variable Initialization



    // Actions

    if (!runActions) {

        return true;

    }



    TriggerEnable(TriggerGetCurrent(), false);

    auto6249E76F_g = UnitGroup("DiabloShrine", c_playerAny, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);

    auto6249E76F_u = UnitGroupCount(auto6249E76F_g, c_unitCountAll);

    for (;; auto6249E76F_u -= 1) {

        lv_u = UnitGroupUnitFromEnd(auto6249E76F_g, auto6249E76F_u);

        if (lv_u == null) { break; }

        UnitGroupAdd(libMSHE_gv_mMISInactiveShrines, lv_u);

        ActorSend(libNtve_gf_MainActorofUnit(lv_u), "MinimapIcon Assets\\Textures\\storm_ui_minimapicon_shrine_active.dds");

        ActorSend(libNtve_gf_MainActorofUnit(lv_u), "MinimapIconTintColor 255,145,113,218");

        libNtve_gf_SendActorMessageToUnit(lv_u, "SetMinimapVisibility");

        libNtve_gf_SendActorMessageToUnit(lv_u, "SetMinimapVisibilityAlways");

        UnitSetState(lv_u, c_unitStateHighlightable, false);

        UnitSetState(lv_u, c_unitStateTargetable, false);

    }

    return true;

}



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

void libMSHE_gt_MMISInitializeShrines_Init () {

    libMSHE_gt_MMISInitializeShrines = TriggerCreate("libMSHE_gt_MMISInitializeShrines_Func");

}



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

// Trigger: MM IS Shrine Timer Expired

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

bool libMSHE_gt_MMISShrineTimerExpired_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    int auto46972FA4_val;



    // Actions

    if (!runActions) {

        return true;

    }



    libMSHE_gv_mMISShrineIsActive = true;

    TimerStart(libMSHE_gv_mMISShrineWarningTimer, libMSHE_gv_mMDiabloShrinesShrineTimerWarning, false, c_timeGame);

    AddUnitOfInterest(libMSHE_gv_mMISShrines[libMSHE_gv_mMISCurrentShrine], 14.0, (libMSHE_gv_mMDiabloShrinesShrineTimerWarning + 1.0), "FightAtShrine", libNtve_ge_GoalTeam_Both, 0);

    libMSHE_gf_MMISWarningAnnouncementShrine(libMSHE_gv_mMISCurrentShrine);

    PlayerGroupRemove(libMSHE_gv_mMISShrineGroup, libMSHE_gv_mMISBuffIndex);

    DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_crystalFrozenIcon, PlayerGroupAll(), false);

    DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_crystalMortarIcon, PlayerGroupAll(), false);

    DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_crystalArcaneIcon, PlayerGroupAll(), false);

    auto46972FA4_val = libMSHE_gv_mMISBuffIndex;

    if (auto46972FA4_val == 1) {

        libMSHE_gv_mMISBuff = "FrozenShrine";

        libMSHE_gv_mMISLastBuff = 1;

        DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_crystalFrozenIcon, PlayerGroupAll(), true);

    }

    else if (auto46972FA4_val == 2) {

        libMSHE_gv_mMISBuff = "BombardShrine";

        libMSHE_gv_mMISLastBuff = 2;

        DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_crystalMortarIcon, PlayerGroupAll(), true);

    }

    else if (auto46972FA4_val == 3) {

        libMSHE_gv_mMISBuff = "ArcaneShrine";

        libMSHE_gv_mMISLastBuff = 3;

        DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_crystalArcaneIcon, PlayerGroupAll(), true);

    }

    else {

    }

    libMSHD_gf_MMISPreloadPunisherModels(libMSHE_gv_mMISBuff);

    if ((libGame_gv_gameOver == false)) {

        SoundtrackPlay(PlayerGroupAll(), c_soundtrackCategoryMusic, "MX_Event_Shrines_Spawn", c_soundtrackCueAny, c_soundtrackIndexAny, false);

    }



    return true;

}



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

void libMSHE_gt_MMISShrineTimerExpired_Init () {

    libMSHE_gt_MMISShrineTimerExpired = TriggerCreate("libMSHE_gt_MMISShrineTimerExpired_Func");

    TriggerAddEventTimer(libMSHE_gt_MMISShrineTimerExpired, libMSHE_gv_mMISShrineTimer);

}



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

// Trigger: MM IS Objective Preview Timer Expires

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

bool libMSHE_gt_MMISObjectivePreviewTimerExpires_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Actions

    if (!runActions) {

        return true;

    }



    libMSHE_gf_MMISRandomizeNextShrineandShowPreview();

    return true;

}



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

void libMSHE_gt_MMISObjectivePreviewTimerExpires_Init () {

    libMSHE_gt_MMISObjectivePreviewTimerExpires = TriggerCreate("libMSHE_gt_MMISObjectivePreviewTimerExpires_Func");

    TriggerAddEventTimer(libMSHE_gt_MMISObjectivePreviewTimerExpires, libMSHE_gv_mMISObjectivePreviewTimer);

}



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

// Trigger: MM IS Buff Timer Expired

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

bool libMSHE_gt_MMISBuffTimerExpired_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_itUnit;

    int lv_itPlayer;



    // Automatic Variable Declarations

    unitgroup auto92397144_g;

    int auto92397144_u;



    // Variable Initialization



    // Actions

    if (!runActions) {

        return true;

    }



    TimerStart(libMSHE_gv_mMISShrineTimer, libMSHE_gv_mMDiabloShrinesShrineTimerDuration_C, false, c_timeGame);

    auto92397144_g = libMSHE_gv_mMISParalyzeStorage;

    auto92397144_u = UnitGroupCount(auto92397144_g, c_unitCountAll);

    for (;; auto92397144_u -= 1) {

        lv_itUnit = UnitGroupUnitFromEnd(auto92397144_g, auto92397144_u);

        if (lv_itUnit == null) { break; }

        UnitRemove(lv_itUnit);

    }

    return true;

}



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

void libMSHE_gt_MMISBuffTimerExpired_Init () {

    libMSHE_gt_MMISBuffTimerExpired = TriggerCreate("libMSHE_gt_MMISBuffTimerExpired_Func");

    TriggerAddEventTimer(libMSHE_gt_MMISBuffTimerExpired, libMSHE_gv_mMISBuffTimer);

}



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

// Trigger: MM IS Warning Timer Expired

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

bool libMSHE_gt_MMISWarningTimerExpired_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libGame_gv_gameOver == false))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    UnitBehaviorRemove(libMSHE_gv_mMISShrines[libMSHE_gv_mMISCurrentShrine], "DiabloShrineWarningFX", 1);

    libMSHE_gf_MMISTransmissionShrineActivating();

    libMSHE_gf_MMISActivateShrine(libMSHE_gv_mMISCurrentShrine);

    libMSHE_gv_mMISNumberOfShrinesEvents += 1;

    libMSHE_gv_mMISLastShrineCounter = 0;

    return true;

}



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

void libMSHE_gt_MMISWarningTimerExpired_Init () {

    libMSHE_gt_MMISWarningTimerExpired = TriggerCreate("libMSHE_gt_MMISWarningTimerExpired_Func");

    TriggerAddEventTimer(libMSHE_gt_MMISWarningTimerExpired, libMSHE_gv_mMISShrineWarningTimer);

}



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

// Trigger: MM IS Start Shrine Timer

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

bool libMSHE_gt_MMISStartShrineTimer_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((EventUnit() == libMSHE_gv_mMISPunisher))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    TriggerEnable(libMSHE_gt_PunisherDurationTracking, false);

    TimerStart(libMSHE_gv_mMISShrineTimer, libMSHE_gv_mMDiabloShrinesShrineTimerDuration_C, false, c_timeGame);

    TimerStart(libMSHE_gv_mMISObjectivePreviewTimer, libMSHE_gv_mMISObjectivePreviewDelay_C, false, c_timeGame);

    if ((UnitGetOwner(EventUnit()) == libCore_gv_cOMPUTER_TeamOrder)) {

        SoundtrackPlay(PlayerGroupAll(), c_soundtrackCategoryMusic, "MX_Event_Shrines_Punisher_Heaven_End", c_soundtrackCueAny, c_soundtrackIndexAny, false);

    }

    else {

        SoundtrackPlay(PlayerGroupAll(), c_soundtrackCategoryMusic, "MX_Event_Shrines_Punisher_Hell_End", c_soundtrackCueAny, c_soundtrackIndexAny, false);

    }

    libSond_gf_SoundtrackPlayMapSoundtrackAsDefaultSoundtrackForAllPlayers();

    StatEventCreate("Punisher Killed");

    StatEventAddDataInt(StatEventLastCreated(), "Event", libMSHE_gv_mMISNumberOfShrinesEvents);

    StatEventAddDataInt(StatEventLastCreated(), "Owning Team of Punisher", libGame_gf_TeamNumberOfPlayer(EventPlayer()));

    StatEventAddDataString(StatEventLastCreated(), "Punisher Type", (libMSHE_gv_mMISBuff));

    StatEventAddDataFixed(StatEventLastCreated(), "Siege Damage Done", libMSHE_gv_punisherSiegeDamage);

    StatEventAddDataFixed(StatEventLastCreated(), "Hero Damage Done", libMSHE_gv_punisherHeroDamage);

    StatEventAddDataInt(StatEventLastCreated(), "Duration", libMSHE_gv_punisherDuration);

    StatEventSend(StatEventLastCreated());

    libMSHE_gv_punisherSiegeDamage = 0.0;

    libMSHE_gv_punisherHeroDamage = 0.0;

    libMSHE_gv_punisherDuration = 0;

    libMSHE_gf_MMISTransmissionPunisherKilled(libGame_gf_TeamNumberOfPlayer(UnitGetOwner(EventUnit())));

    TriggerEnable(TriggerGetCurrent(), false);

    return true;

}



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

void libMSHE_gt_MMISStartShrineTimer_Init () {

    libMSHE_gt_MMISStartShrineTimer = TriggerCreate("libMSHE_gt_MMISStartShrineTimer_Func");

    TriggerEnable(libMSHE_gt_MMISStartShrineTimer, false);

    TriggerAddEventUnitDied(libMSHE_gt_MMISStartShrineTimer, null);

}



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

// Trigger: MM IS Shrine Used by Player

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

bool libMSHE_gt_MMISShrineUsedbyPlayer_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_shrine;

    int lv_team;

    int lv_owner;



    // Automatic Variable Declarations

    const int autoCF944CF4_n = libMSHE_gv_mMISTotalMonsters_C;

    int autoCF944CF4_i;



    // Variable Initialization

    lv_shrine = EventPlayerEffectUsedUnit(c_effectUnitTarget);



    // Conditions

    if (testConds) {

        if (!((UnitGroupHasUnit(libMSHE_gv_mMISActiveShrines, EventPlayerEffectUsedUnit(c_effectUnitTarget)) == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    lv_owner = EventPlayerEffectUsedUnitOwner(c_effectPlayerCaster);

    libMSHE_gv_mMISCursedEvent = true;

    UnitGroupRemove(libMSHE_gv_mMISActiveShrines, lv_shrine);

    UnitBehaviorRemove(libMSHE_gv_mMISShrines[libMSHE_gv_mMISCurrentShrine], "MacguffinActivated", 1);

    UnitSetState(libMSHE_gv_mMISShrines[libMSHE_gv_mMISCurrentShrine], c_unitStateHighlightable, false);

    UnitSetState(libMSHE_gv_mMISShrines[libMSHE_gv_mMISCurrentShrine], c_unitStateTargetable, false);

    ActorSend(libNtve_gf_MainActorofUnit(libMSHE_gv_mMISShrines[libMSHE_gv_mMISCurrentShrine]), "Signal Activate");

    TimerPause(libMSHE_gv_mMISShrineReminderTimer, true);

    TriggerEnable(libMSHE_gt_MMISCursedEventMinionTracker, true);

    TriggerEnable(libMSHE_gt_MMISCursedEventScoreTracker, true);

    TriggerEnable(libMSHE_gt_MMISCursedEventTimerRespawner, true);

    libMSHE_gf_MMISTextTagScoreHandler(libGame_gv_teamChaosIndex_C, libGame_gv_teamOrderIndex_C, libMSHE_gv_mMISShrines[libMSHE_gv_mMISCurrentShrine]);

    libMSHE_gf_MMISTextTagScoreHandler(libGame_gv_teamOrderIndex_C, libGame_gv_teamChaosIndex_C, libMSHE_gv_mMISShrines[libMSHE_gv_mMISCurrentShrine]);

    for (autoCF944CF4_i = 1; autoCF944CF4_i <= autoCF944CF4_n; autoCF944CF4_i += 1) {

        UnitIssueOrder(libMSHE_gv_mMISShrines[libMSHE_gv_mMISCurrentShrine], OrderTargetingPoint(AbilityCommand("CursedShrineSpawn", 0), RegionRandomPoint(libMSHE_gv_mMISRegions[libMSHE_gv_mMISCurrentShrine])), c_orderQueueReplace);

        Wait(0.15, c_timeGame);

    }

    TimerStart(libMSHE_gv_mMISCursedRefreshTimer, libMSHE_gv_mMDiabloShrineRefreshMonster_C, false, c_timeGame);

    return true;

}



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

void libMSHE_gt_MMISShrineUsedbyPlayer_Init () {

    libMSHE_gt_MMISShrineUsedbyPlayer = TriggerCreate("libMSHE_gt_MMISShrineUsedbyPlayer_Func");

    TriggerAddEventPlayerEffectUsed(libMSHE_gt_MMISShrineUsedbyPlayer, c_playerAny, "CaptureMacGuffinCastComplete");

}



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

// Trigger: Game Over

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

bool libMSHE_gt_GameOver_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_itPlayer;



    // Automatic Variable Declarations

    const int autoBCDC98C8_ae = libCore_gv_bALMaxPlayers;

    const int autoBCDC98C8_ai = 1;



    // Variable Initialization



    // Actions

    if (!runActions) {

        return true;

    }



    lv_itPlayer = 1;

    for ( ; ( (autoBCDC98C8_ai >= 0 && lv_itPlayer <= autoBCDC98C8_ae) || (autoBCDC98C8_ai < 0 && lv_itPlayer >= autoBCDC98C8_ae) ) ; lv_itPlayer += autoBCDC98C8_ai ) {

        libGame_gf_ScoreValuesReportIntegerValueAndLog(lv_itPlayer, "DamageDoneToShrineMinions", libMSHE_gv_mMISDamageDoneToShrineMinions[lv_itPlayer]);

    }

    return true;

}



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

void libMSHE_gt_GameOver_Init () {

    libMSHE_gt_GameOver = TriggerCreate("libMSHE_gt_GameOver_Func");

    libGame_gf_GameOverEvent(libMSHE_gt_GameOver);

}



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

// Trigger: MM IS Shrine Reminder Timer Expired

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

bool libMSHE_gt_MMISShrineReminderTimerExpired_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libMSHE_gv_mMISCursedEvent == false))) {

            return false;

        }



        if (!((libGame_gv_gameOver == false))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libCore_gf_CreateMinimapPingStorm(PlayerGroupAll(), "StormAlert", UnitGetPosition(libMSHE_gv_mMISShrines[libMSHE_gv_mMISCurrentShrine]), ColorWithAlpha(100.00, 100.00, 0.00, 0.00), 4.0);

    TimerStart(libMSHE_gv_mMISShrineReminderTimer, libMSHE_gv_mMISShrineReminderDelay_C, false, c_timeGame);

    return true;

}



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

void libMSHE_gt_MMISShrineReminderTimerExpired_Init () {

    libMSHE_gt_MMISShrineReminderTimerExpired = TriggerCreate("libMSHE_gt_MMISShrineReminderTimerExpired_Func");

    TriggerAddEventTimer(libMSHE_gt_MMISShrineReminderTimerExpired, libMSHE_gv_mMISShrineReminderTimer);

}



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

// Trigger: MMInfernalShrines Player Moves Camera

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

bool libMSHE_gt_MMInfernalShrinesPlayerMovesCamera_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_itPlayer;



    // Automatic Variable Declarations

    const int auto2F856B69_ae = libCore_gv_bALMaxPlayers;

    const int auto2F856B69_ai = 1;



    // Variable Initialization



    // Actions

    if (!runActions) {

        return true;

    }



    lv_itPlayer = 1;

    for ( ; ( (auto2F856B69_ai >= 0 && lv_itPlayer <= auto2F856B69_ae) || (auto2F856B69_ai < 0 && lv_itPlayer >= auto2F856B69_ae) ) ; lv_itPlayer += auto2F856B69_ai ) {

        if ((PlayerStatus(lv_itPlayer) == c_playerStatusActive) && (PlayerType(lv_itPlayer) == c_playerTypeUser)) {

            libMSHE_gf_MMBOEUpdateAmbience(lv_itPlayer);

        }



    }

    libMSHE_gf_MMBOEUpdateAmbience(libCore_gv_oBSERVER_ObserverUIPlayer);

    return true;

}



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

void libMSHE_gt_MMInfernalShrinesPlayerMovesCamera_Init () {

    libMSHE_gt_MMInfernalShrinesPlayerMovesCamera = TriggerCreate("libMSHE_gt_MMInfernalShrinesPlayerMovesCamera_Func");

    TriggerAddEventTimePeriodic(libMSHE_gt_MMInfernalShrinesPlayerMovesCamera, 0.5, c_timeGame);

}



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

// Trigger: MM IS Affix Scaling

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

bool libMSHE_gt_MMISAffixScaling_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Actions

    if (!runActions) {

        return true;

    }



    TimerStart(libMSHE_gv_mMISAffixTimer, libMSHE_gv_mMISAffixTimerDuration, false, c_timeGame);

    CatalogFieldValueSet(c_gameCatalogEffect, "DiabloMoltenDamage", "Amount", libCore_gv_cOMPUTER_TeamOrder, IntToString((CatalogFieldValueGetAsInt(c_gameCatalogEffect, "DiabloMoltenDamage", "Amount", libCore_gv_cOMPUTER_TeamOrder) + libMSHE_gv_mMISMoltenScalingAmount_C)));

    CatalogFieldValueSet(c_gameCatalogEffect, "DiabloMortarDamage", "Amount", libCore_gv_cOMPUTER_TeamOrder, IntToString((CatalogFieldValueGetAsInt(c_gameCatalogEffect, "DiabloMortarDamage", "Amount", libCore_gv_cOMPUTER_TeamOrder) + libMSHE_gv_mMISMortarScalingAmount_C)));

    CatalogFieldValueSet(c_gameCatalogEffect, "DiabloThunderstormDamage", "Amount", libCore_gv_cOMPUTER_TeamOrder, IntToString((CatalogFieldValueGetAsInt(c_gameCatalogEffect, "DiabloThunderstormDamage", "Amount", libCore_gv_cOMPUTER_TeamOrder) + libMSHE_gv_mMISThunderstormScalingAmount_C)));

    CatalogFieldValueSet(c_gameCatalogEffect, "DiabloFrozenDamage", "Amount", libCore_gv_cOMPUTER_TeamOrder, IntToString((CatalogFieldValueGetAsInt(c_gameCatalogEffect, "DiabloFrozenDamage", "Amount", libCore_gv_cOMPUTER_TeamOrder) + libMSHE_gv_mMISThunderstormScalingAmount_C)));

    CatalogFieldValueSet(c_gameCatalogEffect, "DiabloArcaneDamage", "Amount", libCore_gv_cOMPUTER_TeamOrder, IntToString((CatalogFieldValueGetAsInt(c_gameCatalogEffect, "DiabloArcaneDamage", "Amount", libCore_gv_cOMPUTER_TeamOrder) + libMSHE_gv_mMISArcaneScalingAmount_C)));

    CatalogFieldValueSet(c_gameCatalogEffect, "DiabloMoltenDamage", "Amount", libCore_gv_cOMPUTER_TeamChaos, IntToString((CatalogFieldValueGetAsInt(c_gameCatalogEffect, "DiabloMoltenDamage", "Amount", libCore_gv_cOMPUTER_TeamChaos) + libMSHE_gv_mMISMoltenScalingAmount_C)));

    CatalogFieldValueSet(c_gameCatalogEffect, "DiabloMortarDamage", "Amount", libCore_gv_cOMPUTER_TeamChaos, IntToString((CatalogFieldValueGetAsInt(c_gameCatalogEffect, "DiabloMortarDamage", "Amount", libCore_gv_cOMPUTER_TeamChaos) + libMSHE_gv_mMISMortarScalingAmount_C)));

    CatalogFieldValueSet(c_gameCatalogEffect, "DiabloThunderstormDamage", "Amount", libCore_gv_cOMPUTER_TeamChaos, IntToString((CatalogFieldValueGetAsInt(c_gameCatalogEffect, "DiabloThunderstormDamage", "Amount", libCore_gv_cOMPUTER_TeamChaos) + libMSHE_gv_mMISThunderstormScalingAmount_C)));

    CatalogFieldValueSet(c_gameCatalogEffect, "DiabloFrozenDamage", "Amount", libCore_gv_cOMPUTER_TeamChaos, IntToString((CatalogFieldValueGetAsInt(c_gameCatalogEffect, "DiabloFrozenDamage", "Amount", libCore_gv_cOMPUTER_TeamChaos) + libMSHE_gv_mMISThunderstormScalingAmount_C)));

    CatalogFieldValueSet(c_gameCatalogEffect, "DiabloArcaneDamage", "Amount", libCore_gv_cOMPUTER_TeamChaos, IntToString((CatalogFieldValueGetAsInt(c_gameCatalogEffect, "DiabloArcaneDamage", "Amount", libCore_gv_cOMPUTER_TeamChaos) + libMSHE_gv_mMISArcaneScalingAmount_C)));

    return true;

}



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

void libMSHE_gt_MMISAffixScaling_Init () {

    libMSHE_gt_MMISAffixScaling = TriggerCreate("libMSHE_gt_MMISAffixScaling_Func");

    TriggerAddEventTimer(libMSHE_gt_MMISAffixScaling, libMSHE_gv_mMISAffixTimer);

}



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

// Trigger: Punisher - Leap

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

bool libMSHE_gt_PunisherLeap_Func (bool testConds, bool runActions) {

    // Variable Declarations

    fixed lv_abilityRange;

    point lv_playerTargetPoint;

    fixed lv_distanceFromBarbarianToPlayerTargetPoint;

    fixed lv_barbarianRadius;

    point lv_actualTargetPoint;

    fixed lv_modifiedDistance;



    // Automatic Variable Declarations

    unitgroup auto8019A886_g;

    int auto8019A886_u;

    unit auto8019A886_var;



    // Variable Initialization



    // Actions

    if (!runActions) {

        return true;

    }



    lv_barbarianRadius = StringToFixed(CatalogFieldValueGet(c_gameCatalogUnit, (UnitGetType(EventPlayerEffectUsedUnit(c_effectUnitCaster))), "Radius", EventPlayerEffectUsedUnitOwner(c_effectPlayerCaster)));

    lv_abilityRange = (StringToFixed(CatalogFieldValueGet(c_gameCatalogActor, "MercPunisherLanerLeapRangeSplat", "Scale", EventPlayerEffectUsedUnitOwner(c_effectPlayerCaster))) + lv_barbarianRadius);

    lv_playerTargetPoint = EventPlayerEffectUsedPoint(c_effectLocationTargetPoint);

    lv_distanceFromBarbarianToPlayerTargetPoint = DistanceBetweenPoints(UnitGetPosition(EventPlayerEffectUsedUnit(c_effectUnitCaster)), lv_playerTargetPoint);

    lv_actualTargetPoint = lv_playerTargetPoint;

    auto8019A886_g = UnitGroupSearch(null, c_playerAny, lv_playerTargetPoint, 1.5, UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);

    auto8019A886_u = UnitGroupCount(auto8019A886_g, c_unitCountAll);

    for (;; auto8019A886_u -= 1) {

        auto8019A886_var = UnitGroupUnitFromEnd(auto8019A886_g, auto8019A886_u);

        if (auto8019A886_var == null) { break; }

        if ((UnitTypeTestFlag(UnitGetType(auto8019A886_var), c_unitFlagTownStructureGate) == true)) {

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

            lv_actualTargetPoint = libNtve_gf_PointOffsetTowardsPoint(UnitGetPosition(EventPlayerEffectUsedUnit(c_effectUnitCaster)), (lv_distanceFromBarbarianToPlayerTargetPoint - (lv_barbarianRadius + 0.25)), lv_playerTargetPoint);

        }



    }

    if ((lv_distanceFromBarbarianToPlayerTargetPoint > lv_abilityRange)) {

        lv_actualTargetPoint = libNtve_gf_PointOffsetTowardsPoint(UnitGetPosition(EventPlayerEffectUsedUnit(c_effectUnitCaster)), lv_abilityRange, lv_playerTargetPoint);

    }



    lv_modifiedDistance = lv_distanceFromBarbarianToPlayerTargetPoint;

    while ((PointPathingPassable(lv_actualTargetPoint) == false)) {

        lv_modifiedDistance -= 0.125;

        lv_actualTargetPoint = libNtve_gf_PointOffsetTowardsPoint(UnitGetPosition(EventPlayerEffectUsedUnit(c_effectUnitCaster)), lv_modifiedDistance, lv_playerTargetPoint);

        if ((PointPathingPassable(lv_actualTargetPoint) == false)) {

            lv_actualTargetPoint = PointWithOffsetPolar(libNtve_gf_PointOffsetTowardsPoint(UnitGetPosition(EventPlayerEffectUsedUnit(c_effectUnitCaster)), lv_modifiedDistance, lv_playerTargetPoint), 0.5, (AngleBetweenPoints(UnitGetPosition(EventPlayerEffectUsedUnit(c_effectUnitCaster)), lv_playerTargetPoint) + 90.0));

            if ((PointPathingPassable(lv_actualTargetPoint) == false)) {

                lv_actualTargetPoint = PointWithOffsetPolar(libNtve_gf_PointOffsetTowardsPoint(UnitGetPosition(EventPlayerEffectUsedUnit(c_effectUnitCaster)), lv_modifiedDistance, lv_playerTargetPoint), 0.5, (AngleBetweenPoints(UnitGetPosition(EventPlayerEffectUsedUnit(c_effectUnitCaster)), lv_playerTargetPoint) - 90.0));

                if ((PointPathingPassable(lv_actualTargetPoint) == false)) {

                    lv_actualTargetPoint = libNtve_gf_PointOffsetTowardsPoint(UnitGetPosition(EventPlayerEffectUsedUnit(c_effectUnitCaster)), lv_modifiedDistance, lv_playerTargetPoint);

                }



            }



        }



        if ((DistanceBetweenPoints(UnitGetPosition(EventPlayerEffectUsedUnit(c_effectUnitCaster)), lv_actualTargetPoint) <= (lv_barbarianRadius + 0.125))) {

            libNtve_gf_UIErrorMessage(libCore_gv_playerGroupFromPlayer[EventPlayerEffectUsedUnitOwner(c_effectPlayerCaster)], StringExternal("Param/Value/lib_MSHE_6BC67266"), SoundLink("UI_GenericError", -1));

            UnitBehaviorRemove(EventPlayerEffectUsedUnit(c_effectUnitCaster), "MercPunisherLanerLeap", 1);

            UnitAbilityReset(EventPlayerEffectUsedUnit(c_effectUnitCaster), AbilityCommand("MercPunisherLanerLeap", 0), c_spendLocationAll);

            return true;

        }



    }

    if ((UnitIsAlive(EventPlayerEffectUsedUnit(c_effectUnitCaster)) == true)) {

        UnitCreateEffectPointWithSource(EventPlayerEffectUsedUnit(c_effectUnitCaster), "MercPunisherLanerLeapLaunchMissile", lv_actualTargetPoint, c_gameCatalogAbil, "MercPunisherLanerLeap");

        UnitCreateEffectPoint(EventPlayerEffectUsedUnit(c_effectUnitCaster), "MercPunisherLanerLeapCreateWarningPersistent", lv_actualTargetPoint);

    }



    return true;

}



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

void libMSHE_gt_PunisherLeap_Init () {

    libMSHE_gt_PunisherLeap = TriggerCreate("libMSHE_gt_PunisherLeap_Func");

    TriggerAddEventPlayerEffectUsed(libMSHE_gt_PunisherLeap, c_playerAny, "MercPunisherLanerLeapInitialSet");

    TriggerAddEventPlayerEffectUsed(libMSHE_gt_PunisherLeap, c_playerAny, "MercPunisherLanerLeapNoMovementInitialSet");

}



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

// Trigger: Punisher - Fixate On

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

bool libMSHE_gt_PunisherFixateOn_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_punisher;



    // Automatic Variable Declarations

    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((UnitIsAlive(EventUnit()) == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    lv_punisher = EventUnit();

    libAIAI_gf_MinionAIUnhookUnitFromMinionAI(lv_punisher);

    Wait(1.0, c_timeGame);

    if ((UnitIsAlive(lv_punisher) == true) && (UnitHasBehavior2(lv_punisher, "MercPunisherLanerFixate") == false)) {

        libGame_gf_CalculateSpawnedMinionGoalPointsFromLane(UnitGetOwner(lv_punisher), UnitGetPosition(lv_punisher), libMSHE_gv_mMDiabloShrinesPunisherPushLane);

        libAIAI_gf_MinionAIStartMinionAI(-1, lv_punisher, libGame_gv_spawnedMinionLane, libGame_gv_spawnedMinionFirstWaypointIndex, false, true, false, libGame_gf_EnemyTeam(libGame_gf_TeamNumberOfPlayer(UnitGetOwner(lv_punisher))), false);

    }



    return true;

}



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

void libMSHE_gt_PunisherFixateOn_Init () {

    libMSHE_gt_PunisherFixateOn = TriggerCreate("libMSHE_gt_PunisherFixateOn_Func");

    TriggerAddEventUnitAbility(libMSHE_gt_PunisherFixateOn, null, AbilityCommand("MercPunisherLanerLeap", 0), c_abilEffectStagePrep, false);

}



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

// Trigger: Punisher - Fixate Off

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

bool libMSHE_gt_PunisherFixateOff_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((UnitIsAlive(EventUnit()) == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libGame_gf_CalculateSpawnedMinionGoalPointsFromLane(UnitGetOwner(EventUnit()), UnitGetPosition(EventUnit()), libMSHE_gv_mMDiabloShrinesPunisherPushLane);

    libAIAI_gf_MinionAIStartMinionAI(-1, EventUnit(), libGame_gv_spawnedMinionLane, libGame_gv_spawnedMinionFirstWaypointIndex, false, true, false, libGame_gf_EnemyTeam(libGame_gf_TeamNumberOfPlayer(UnitGetOwner(EventUnit()))), false);

    return true;

}



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

void libMSHE_gt_PunisherFixateOff_Init () {

    libMSHE_gt_PunisherFixateOff = TriggerCreate("libMSHE_gt_PunisherFixateOff_Func");

    TriggerAddEventUnitBehaviorChange(libMSHE_gt_PunisherFixateOff, null, "MercPunisherLanerFixateExhausted", c_unitBehaviorChangeDeactivate);

}



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

// Trigger: Punisher - Damage Tracking

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

bool libMSHE_gt_PunisherDamageTracking_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((EventUnitDamageSourceUnit() == libMSHE_gv_mMISUIPunisherUnit))) {

            return false;

        }



        if (!(((UnitTypeTestAttribute(UnitGetType(EventUnit()), c_unitAttributeHeroic) == true) || (UnitTypeTestAttribute(UnitGetType(EventUnit()), c_unitAttributeStructure) == true) || (UnitTypeTestAttribute(UnitGetType(EventUnit()), c_unitAttributeMinion) == true)))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((UnitTypeTestAttribute(UnitGetType(EventUnit()), c_unitAttributeHeroic) == true)) {

        libMSHE_gv_punisherHeroDamage += EventUnitDamageAmount();

    }

    else {

        libMSHE_gv_punisherSiegeDamage += EventUnitDamageAmount();

    }

    return true;

}



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

void libMSHE_gt_PunisherDamageTracking_Init () {

    libMSHE_gt_PunisherDamageTracking = TriggerCreate("libMSHE_gt_PunisherDamageTracking_Func");

    TriggerAddEventUnitDamaged(libMSHE_gt_PunisherDamageTracking, null, c_unitDamageTypeAny, c_unitDamageEither, null);

}



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

// Trigger: Punisher - Duration Tracking

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

bool libMSHE_gt_PunisherDurationTracking_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Actions

    if (!runActions) {

        return true;

    }



    libMSHE_gv_punisherDuration += 1;

    return true;

}



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

void libMSHE_gt_PunisherDurationTracking_Init () {

    libMSHE_gt_PunisherDurationTracking = TriggerCreate("libMSHE_gt_PunisherDurationTracking_Func");

    TriggerEnable(libMSHE_gt_PunisherDurationTracking, false);

    TriggerAddEventTimePeriodic(libMSHE_gt_PunisherDurationTracking, 1.0, c_timeGame);

}



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

// Trigger: MM IS UI Mod Initialize

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

bool libMSHE_gt_MMISUIModInitialize_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Actions

    if (!runActions) {

        return true;

    }



    libMSHE_gf_MMTowerPushUIInit(libUIUI_gv_mapMechanicsPanel.lv_mainPanel);

    return true;

}



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

void libMSHE_gt_MMISUIModInitialize_Init () {

    libMSHE_gt_MMISUIModInitialize = TriggerCreate("libMSHE_gt_MMISUIModInitialize_Func");

    libCore_gf_IncludeModInitialization(libMSHE_gt_MMISUIModInitialize);

}



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

// Trigger: MM IS UI Handler

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

bool libMSHE_gt_MMISUIHandler_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_state;

    int lv_lastState;

    int lv_itTeam;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_state = libMSHE_ge_MMISUIModes_Idle;

    lv_lastState = libMSHE_ge_MMISUIModes_Idle;



    // Conditions

    if (testConds) {

        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    TriggerEnable(TriggerGetCurrent(), false);

    while (true) {

        if ((TimerIsPaused(libMSHE_gv_mMISShrineWarningTimer) == false) && (TimerGetRemaining(libMSHE_gv_mMISShrineWarningTimer) > 0.0)) {

            lv_state = libMSHE_ge_MMISUIModes_ShrineWarning;

            if ((lv_state != lv_lastState)) {

                libMSHE_gf_MMTowerPushUISetMode(libMSHE_ge_MMISUIModes_ShrineWarning);

            }



            libMSHE_gf_MMTowerPushUISetEnergyGlobalProgressUnit3(FixedToInt(TimerGetRemaining(libMSHE_gv_mMISShrineWarningTimer)));

            lv_lastState = lv_state;

        }

        else if ((TimerIsPaused(libMSHE_gv_mMISShrineTimer) == false) && (TimerGetRemaining(libMSHE_gv_mMISShrineTimer) > 0.0) && (libMSHE_gv_mMISShowOjectiveTimer == true)) {

            lv_state = libMSHE_ge_MMISUIModes_ShrineWarning;

            if ((lv_state != lv_lastState)) {

                libMSHE_gf_MMTowerPushUISetMode(libMSHE_ge_MMISUIModes_ShrineWarning);

            }



            libMSHE_gf_MMTowerPushUISetEnergyGlobalProgressUnit3(FixedToInt((TimerGetRemaining(libMSHE_gv_mMISShrineTimer) + libMSHE_gv_mMDiabloShrinesShrineTimerWarning)));

            lv_lastState = lv_state;

        }

        else if ((lv_lastState == libMSHE_ge_MMISUIModes_ShrineWarning) && (libMSHE_gv_mMISCursedEvent == false) && (TimerGetRemaining(libMSHE_gv_mMISShrineNotificationTimer) > 0.0)) {

            if ((lv_lastState != libMSHE_ge_MMISUIModes_CursedEvent)) {

                lv_state = libMSHE_ge_MMISUIModes_ShrineActive;

                if ((lv_lastState != lv_state)) {

                    libMSHE_gf_MMTowerPushUISetMode(libMSHE_ge_MMISUIModes_ShrineActive);

                }

                else {

                    lv_lastState = lv_state;

                }

            }



        }

        else if ((libMSHE_gv_mMISCursedEvent == true)) {

            if ((lv_lastState != libMSHE_ge_MMISUIModes_Punisher)) {

                lv_state = libMSHE_ge_MMISUIModes_CursedEvent;

                if ((lv_state != lv_lastState)) {

                    libMSHE_gf_MMTowerPushUISetMode(libMSHE_ge_MMISUIModes_CursedEvent);

                }



                libMSHE_gf_MMTowerPushUISetGoblinCount(libMSHE_gv_mMISKillCount[1], libMSHE_gv_mMISKillCount[2]);

                lv_lastState = lv_state;

            }



        }

        else if ((UnitIsAlive(libMSHE_gv_mMISPunisher) == true)) {

            lv_state = libMSHE_ge_MMISUIModes_Punisher;

            if ((lv_state != lv_lastState)) {

                libMSHE_gf_MMTowerPushUISetMode(libMSHE_ge_MMISUIModes_Punisher);

            }



            libMSHE_gf_MMTowerPushUISetEnergyGlobalProgressUnit(libMSHE_gv_mMISPunisher);

            libNtve_gf_SetDialogItemText(libMSHE_gv_mMTowerPushPanel.lv_punisherInfoLabel, libMSHE_gv_mMISShrineBuffText, PlayerGroupAll());

            lv_lastState = lv_state;

        }

        else if ((TimerGetRemaining(libMSHE_gv_mMISPunisherSpawnTimer) > 0.0)) {

            lv_state = libMSHE_ge_MMISUIModes_PunisherSpawning;

            if ((lv_state != lv_lastState)) {

                libMSHE_gf_MMTowerPushUISetMode(libMSHE_ge_MMISUIModes_PunisherSpawning);

                libMSHE_gf_MMISUIPunisherSpawnTimer(libMSHE_gv_mMISBuffedTeam);

            }



            libMSHE_gf_MMTowerPushUISetEnergyGlobalProgressUnit(libMSHE_gv_mMISPunisher);

            libNtve_gf_SetDialogItemText(libMSHE_gv_mMTowerPushPanel.lv_punisherInfoLabel, libMSHE_gv_mMISShrineBuffText, PlayerGroupAll());

            lv_lastState = lv_state;

        }

        else if (true) {

            lv_state = libMSHE_ge_MMISUIModes_Idle;

            if ((lv_state != lv_lastState)) {

                libMSHE_gf_MMTowerPushUISetMode(libMSHE_ge_MMISUIModes_Idle);

            }



            lv_lastState = lv_state;

        }

        Wait(0.25, c_timeGame);

    }

    return true;

}



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

void libMSHE_gt_MMISUIHandler_Init () {

    libMSHE_gt_MMISUIHandler = TriggerCreate("libMSHE_gt_MMISUIHandler_Func");

}



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

// Trigger: MM IS Force Punisher Type

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

bool libMSHE_gt_MMISForcePunisherType_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    string auto75F4B338_val;



    // Conditions

    if (testConds) {

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

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



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

    if (auto75F4B338_val == "arcane") {

        libMSHE_gv_forcedPunisherType = 3;

        libMSHE_gv_mMISBuffIndex = libMSHE_gv_forcedPunisherType;

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

    }

    else if (auto75F4B338_val == "mortar") {

        libMSHE_gv_forcedPunisherType = 2;

        libMSHE_gv_mMISBuffIndex = libMSHE_gv_forcedPunisherType;

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

    }

    else if (auto75F4B338_val == "frozen") {

        libMSHE_gv_forcedPunisherType = 1;

        libMSHE_gv_mMISBuffIndex = libMSHE_gv_forcedPunisherType;

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

    }

    else {

        if ((libMSHE_gv_forcedPunisherType == 0)) {

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

        }

        else {

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

        }

    }

    return true;

}



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

void libMSHE_gt_MMISForcePunisherType_Init () {

    libMSHE_gt_MMISForcePunisherType = TriggerCreate("libMSHE_gt_MMISForcePunisherType_Func");

    TriggerAddEventChatMessage(libMSHE_gt_MMISForcePunisherType, c_playerAny, "forcepunisher", false);

}



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

// Trigger: MM IS Debug Spawn Next Shrine

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

bool libMSHE_gt_MMISDebugSpawnNextShrine_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_shrine;

    int lv_i;

    int lv_shrineIndex;



    // Automatic Variable Declarations

    // Variable Initialization



    // Conditions

    if (testConds) {

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

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((libMSHE_gv_mMISShrineIsActive == true)) {

        UIDisplayMessage(PlayerGroupAll(), c_messageAreaSubtitle, StringExternal("Param/Value/lib_MSHE_FA288074"));

        return true;

    }



    if ((UnitIsAlive(libMSHE_gv_mMISPunisher) == true) && (UnitIsValid(libMSHE_gv_mMISPunisher) == true)) {

        UIDisplayMessage(PlayerGroupAll(), c_messageAreaSubtitle, StringExternal("Param/Value/lib_MSHE_0DBE4449"));

        return true;

    }



    if ((TimerGetDuration(libMSHE_gv_mMISObjectivePreviewTimer) > 0.0)) {

        libNtve_gf_StopTimer(libMSHE_gv_mMISObjectivePreviewTimer);

        libMSHE_gf_MMISRandomizeNextShrineandShowPreview();

    }



    TimerStart(libMSHE_gv_mMISShrineTimer, 1.0, false, c_timeGame);

    UIDisplayMessage(PlayerGroupAll(), c_messageAreaSubtitle, StringExternal("Param/Value/lib_MSHE_D0F9C489"));

    return true;

}



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

void libMSHE_gt_MMISDebugSpawnNextShrine_Init () {

    libMSHE_gt_MMISDebugSpawnNextShrine = TriggerCreate("libMSHE_gt_MMISDebugSpawnNextShrine_Func");

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

    TriggerAddEventChatMessage(libMSHE_gt_MMISDebugSpawnNextShrine, c_playerAny, "EVENTSTART", true);

}



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

// Trigger: MM IS Debug Warning Shrine

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

bool libMSHE_gt_MMISDebugWarningShrine_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    int autoD3439B71_val;



    // Actions

    if (!runActions) {

        return true;

    }



    TimerPause(libMSHE_gv_mMISShrineTimer, true);

    TimerStart(libMSHE_gv_mMISShrineWarningTimer, 1.0, false, c_timeGame);

    if ((libMSHE_gv_mMISNumberOfShrinesEvents == 0)) {

        libMSHE_gv_mMISCurrentShrine = RandomInt(1, libMSHE_gv_mMISNumberofShrinesAllowed);

        libMSHE_gv_mMISBuffIndex = libMSHE_gf_MMISGetWhichShrine();

    }

    else {

        while (((libMSHE_gv_mMISLastShrineCounter < 15) && ((libMSHE_gv_mMISCurrentShrine == libMSHE_gv_mMISLastShrine) || (libMSHE_gv_mMISBuffIndex == libMSHE_gv_mMISLastBuff)))) {

            libMSHE_gv_mMISLastShrineCounter += 1;

            libMSHE_gv_mMISCurrentShrine = RandomInt(1, libMSHE_gv_mMISNumberofShrinesAllowed);

            libMSHE_gv_mMISBuffIndex = libMSHE_gf_MMISGetWhichShrine();

        }

    }

    libMSHE_gf_MMISWarningAnnouncementShrine(libMSHE_gv_mMISCurrentShrine);

    PlayerGroupRemove(libMSHE_gv_mMISShrineGroup, libMSHE_gv_mMISBuffIndex);

    DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_crystalFrozenIcon, PlayerGroupAll(), false);

    DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_crystalMortarIcon, PlayerGroupAll(), false);

    DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_crystalArcaneIcon, PlayerGroupAll(), false);

    autoD3439B71_val = libMSHE_gv_mMISBuffIndex;

    if (autoD3439B71_val == 1) {

        libMSHE_gv_mMISBuff = "FrozenShrine";

        libMSHE_gv_mMISLastBuff = 1;

        DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_crystalFrozenIcon, PlayerGroupAll(), true);

    }

    else if (autoD3439B71_val == 2) {

        libMSHE_gv_mMISBuff = "BombardShrine";

        libMSHE_gv_mMISLastBuff = 2;

        DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_crystalMortarIcon, PlayerGroupAll(), true);

    }

    else if (autoD3439B71_val == 3) {

        libMSHE_gv_mMISBuff = "ArcaneShrine";

        libMSHE_gv_mMISLastBuff = 3;

        DialogControlSetVisible(libMSHE_gv_mMTowerPushPanel.lv_crystalArcaneIcon, PlayerGroupAll(), true);

    }

    else {

    }

    return true;

}



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

void libMSHE_gt_MMISDebugWarningShrine_Init () {

    libMSHE_gt_MMISDebugWarningShrine = TriggerCreate("libMSHE_gt_MMISDebugWarningShrine_Func");

}



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

// Trigger: MM IS Debug Long Shrine Timer

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

bool libMSHE_gt_MMISDebugLongShrineTimer_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

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

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if ((TimerGetRemaining(libMSHE_gv_mMISLongWarningTimer) >= 1)) {

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

        TimerStart(libMSHE_gv_mMISLongWarningTimer, 1.0, false, c_timeGame);

        TriggerEnable(TriggerGetCurrent(), false);

    }



    return true;

}



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

void libMSHE_gt_MMISDebugLongShrineTimer_Init () {

    libMSHE_gt_MMISDebugLongShrineTimer = TriggerCreate("libMSHE_gt_MMISDebugLongShrineTimer_Func");

    TriggerAddEventChatMessage(libMSHE_gt_MMISDebugLongShrineTimer, c_playerAny, "LongTimer", true);

}



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

// Trigger: MM IS Debug Show Objective Timer

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

bool libMSHE_gt_MMISDebugShowObjectiveTimer_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

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

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libMSHE_gv_mMISShowOjectiveTimer = !(libMSHE_gv_mMISShowOjectiveTimer);

    if ((libMSHE_gv_mMISShowOjectiveTimer == true)) {

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

    }

    else {

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

    }

    return true;

}



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

void libMSHE_gt_MMISDebugShowObjectiveTimer_Init () {

    libMSHE_gt_MMISDebugShowObjectiveTimer = TriggerCreate("libMSHE_gt_MMISDebugShowObjectiveTimer_Func");

    TriggerAddEventChatMessage(libMSHE_gt_MMISDebugShowObjectiveTimer, c_playerAny, "showobjectivetimer", true);

}



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

// Trigger: MM IS Debug - DisableEvent

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

bool libMSHE_gt_MMISDebugDisableEvent_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    if (((TimerGetRemaining(libMSHE_gv_mMISShrineTimer) > 0.0))) {

        TriggerEnable(TriggerGetCurrent(), false);

        TimerPause(libMSHE_gv_mMISShrineTimer, true);

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

    }



    return true;

}



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

void libMSHE_gt_MMISDebugDisableEvent_Init () {

    libMSHE_gt_MMISDebugDisableEvent = TriggerCreate("libMSHE_gt_MMISDebugDisableEvent_Func");

    TriggerAddEventChatMessage(libMSHE_gt_MMISDebugDisableEvent, c_playerAny, "DisableEvent", true);

}



void libMSHE_InitTriggers () {

    libMSHE_gt_MMISInit_Init();

    libMSHE_gt_MMISPingDataInit_Init();

    libMSHE_gt_MMISGateOpen_Init();

    libMSHE_gt_MMISWarningTimerLong_Init();

    libMSHE_gt_MMISCursedEventMinionTracker_Init();

    libMSHE_gt_MMISCursedEventScoreTracker_Init();

    libMSHE_gt_MMISCursedEventTimerRespawner_Init();

    libMSHE_gt_MMISCursedEventMinionDamageTracker_Init();

    libMSHE_gt_MMISExperienceTimerExpired_Init();

    libMSHE_gt_MMISInitializeShrines_Init();

    libMSHE_gt_MMISShrineTimerExpired_Init();

    libMSHE_gt_MMISObjectivePreviewTimerExpires_Init();

    libMSHE_gt_MMISBuffTimerExpired_Init();

    libMSHE_gt_MMISWarningTimerExpired_Init();

    libMSHE_gt_MMISStartShrineTimer_Init();

    libMSHE_gt_MMISShrineUsedbyPlayer_Init();

    libMSHE_gt_GameOver_Init();

    libMSHE_gt_MMISShrineReminderTimerExpired_Init();

    libMSHE_gt_MMInfernalShrinesPlayerMovesCamera_Init();

    libMSHE_gt_MMISAffixScaling_Init();

    libMSHE_gt_PunisherLeap_Init();

    libMSHE_gt_PunisherFixateOn_Init();

    libMSHE_gt_PunisherFixateOff_Init();

    libMSHE_gt_PunisherDamageTracking_Init();

    libMSHE_gt_PunisherDurationTracking_Init();

    libMSHE_gt_MMISUIModInitialize_Init();

    libMSHE_gt_MMISUIHandler_Init();

    libMSHE_gt_MMISForcePunisherType_Init();

    libMSHE_gt_MMISDebugSpawnNextShrine_Init();

    libMSHE_gt_MMISDebugWarningShrine_Init();

    libMSHE_gt_MMISDebugLongShrineTimer_Init();

    libMSHE_gt_MMISDebugShowObjectiveTimer_Init();

    libMSHE_gt_MMISDebugDisableEvent_Init();

}



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

// Library Initialization

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

bool libMSHE_InitLib_completed = false;



void libMSHE_InitLib () {

    if (libMSHE_InitLib_completed) {

        return;

    }



    libMSHE_InitLib_completed = true;



    libMSHE_InitLibraries();

    libMSHE_InitVariables();

    libMSHE_InitTriggers();

}