PTR build 2.57.1.98674_ptr. Go to the live site.

mods/heroesmapmods/battlegroundmapmods/infernalshrines.stormmod/base.stormdata/libmshe.galaxy

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