PTR build 2.57.1.98674_ptr. Go to the live site.

mods/heroesmapmods/battlegroundmapmods/braxisholdout.stormmod/base.stormdata/libscho.galaxy

libscho.galaxy
include "TriggerLibs/NativeLib"
include "TriggerLibs/HeroesLib"
include "TriggerLibs/GameLib"
include "TriggerLibs/MapMechanicsLib"
include "TriggerLibs/AILib"
include "TriggerLibs/UILib"
include "TriggerLibs/StartingExperienceLib"
include "TriggerLibs/SoundLib"

include "LibSCHO_h"

//--------------------------------------------------------------------------------------------------
// Library: Braxis Holdout
//--------------------------------------------------------------------------------------------------
// External Library Initialization
void libSCHO_InitLibraries () {
    libNtve_InitVariables();
    libCore_InitVariables();
    libGame_InitVariables();
    libMapM_InitVariables();
    libAIAI_InitVariables();
    libUIUI_InitVariables();
    libStEx_InitVariables();
    libSond_InitVariables();
}

// Variable Initialization
bool libSCHO_InitVariables_completed = false;

void libSCHO_InitVariables () {
    int init_i;
    int init_j;
    int init_i1;
    int init_j1;

    if (libSCHO_InitVariables_completed) {
        return;
    }

    libSCHO_InitVariables_completed = true;

    libSCHO_gv_mMHO_AttackEventTimer = TimerCreate();
    libSCHO_gv_mMHO_AttackEventWarningTimer = TimerCreate();
    libSCHO_gv_mMHO_AttackWaveTimer = TimerCreate();
    for (init_i = 0; init_i <= libSCHO_gv_mMHO_ControlBeaconMaxCount_C; init_i += 1) {
        libSCHO_gv_mMHO_HiveControlBeacons[init_i].lv_enabled = true;
        libSCHO_gv_mMHO_HiveControlBeacons[init_i].lv_pingModelOrder = c_invalidPingId;
        libSCHO_gv_mMHO_HiveControlBeacons[init_i].lv_pingModelChaos = c_invalidPingId;
    }
    for (init_i = 0; init_i <= 6; init_i += 1) {
        libSCHO_gv_mMHO_Factory_Timer[init_i].lv_animationTimer = TimerCreate();
    }
    libSCHO_gv_mMHO_FreeZerglingCount_C = 6;
    libSCHO_gv_mMHO_FreeUltraliskCount_C = 1;
    libSCHO_gv_mMHO_ChaosUltralisks = UnitGroupEmpty();
    libSCHO_gv_mMHO_OrderUltralisks = UnitGroupEmpty();
    for (init_i = 0; init_i <= 2; init_i += 1) {
        for (init_j = 0; init_j <= 3; init_j += 1) {
            libSCHO_gv_mMHO_AttackGroups[init_i][init_j] = UnitGroupEmpty();
        }
    }
    libSCHO_gv_mMHO_ZergWaveGroup = UnitGroupEmpty();
    libSCHO_gv_mMHO_WaveTracker = 1;
    libSCHO_gv_mMHO_ArchangelCurrentPathIndex = 1;
    libSCHO_gv_mMHO_ArchangelPathIndexMax = 1;
    for (init_i = 0; init_i <= libCore_gv_bALMaxTeams; init_i += 1) {
        libSCHO_gv_mMHO_ArchangelLanerPing[init_i] = c_invalidPingId;
    }
    libSCHO_gv_mMHO_Elevator.lv_elevatorInitialRaiseTimer = TimerCreate();
    libSCHO_gv_mMHO_Elevator.lv_elevatorRaiseTimer = TimerCreate();
    libSCHO_gv_mMHO_Elevator.lv_elevatorLowerTimer = TimerCreate();
    libSCHO_gv_mMHO_Elevator.lv_elevatorWasLowered = true;
    for (init_i = 0; init_i <= libCore_gv_bALMaxTeams; init_i += 1) {
        libSCHO_gv_zergDropPodCooldowns[init_i] = TimerCreate();
    }
    for (init_i = 0; init_i <= libCore_gv_bALMaxTeams; init_i += 1) {
        libSCHO_gv_mMHO_ReminderTransmissions[init_i] = c_invalidTransmissionId;
    }
    libSCHO_gv_mMHO_ScalingTimer = TimerCreate();
    libSCHO_gv_mMHOPanel.lv_mainPanel = c_invalidDialogControlId;
    libSCHO_gv_mMHOPanel.lv_zergWarningFrame = c_invalidDialogControlId;
    libSCHO_gv_mMHOPanel.lv_zergWarningInfoFrame = c_invalidDialogControlId;
    libSCHO_gv_mMHOPanel.lv_zergWarningTimerLabel = c_invalidDialogControlId;
    libSCHO_gv_mMHOPanel.lv_zergAttackingFrame = c_invalidDialogControlId;
    libSCHO_gv_mMHOPanel.lv_zergAttackingInfoFrame = c_invalidDialogControlId;
    libSCHO_gv_mMHOPanel.lv_zergAttackingTimerLabel = c_invalidDialogControlId;
    for (init_i1 = 0; init_i1 <= 2; init_i1 += 1) {
        libSCHO_gv_mMHOPanel.lv_beaconProgressFrame[init_i1] = c_invalidDialogControlId;
    }
    for (init_i1 = 0; init_i1 <= 2; init_i1 += 1) {
        for (init_j1 = 0; init_j1 <= 2; init_j1 += 1) {
            libSCHO_gv_mMHOPanel.lv_beaconProgressHUD[init_i1][init_j1] = c_invalidDialogControlId;
        }
    }
    for (init_i1 = 0; init_i1 <= 2; init_i1 += 1) {
        for (init_j1 = 0; init_j1 <= 2; init_j1 += 1) {
            libSCHO_gv_mMHOPanel.lv_beaconProgressHPBar[init_i1][init_j1] = c_invalidDialogControlId;
        }
    }
    for (init_i1 = 0; init_i1 <= 2; init_i1 += 1) {
        for (init_j1 = 0; init_j1 <= 2; init_j1 += 1) {
            libSCHO_gv_mMHOPanel.lv_beaconProgressHPBarLabel[init_i1][init_j1] = c_invalidDialogControlId;
        }
    }
    for (init_i1 = 0; init_i1 <= 2; init_i1 += 1) {
        for (init_j1 = 0; init_j1 <= 2; init_j1 += 1) {
            libSCHO_gv_mMHOPanel.lv_beaconProgressHPBarAnimFrame[init_i1][init_j1] = c_invalidDialogControlId;
        }
    }
    libSCHO_gv_mMHOPanel.lv_beaconStatusFrame = c_invalidDialogControlId;
    for (init_i1 = 0; init_i1 <= libCore_gv_bALMaxTeams; init_i1 += 1) {
        libSCHO_gv_mMHOPanel.lv_beaconStatusTopBeaconDisabledImage[init_i1] = c_invalidDialogControlId;
    }
    for (init_i1 = 0; init_i1 <= libCore_gv_bALMaxTeams; init_i1 += 1) {
        libSCHO_gv_mMHOPanel.lv_dragonShireMoonShrineEnabledImage[init_i1] = c_invalidDialogControlId;
    }
    for (init_i1 = 0; init_i1 <= libCore_gv_bALMaxTeams; init_i1 += 1) {
        libSCHO_gv_mMHOPanel.lv_dragonShireStarShrineDisabledImage[init_i1] = c_invalidDialogControlId;
    }
    for (init_i1 = 0; init_i1 <= libCore_gv_bALMaxTeams; init_i1 += 1) {
        libSCHO_gv_mMHOPanel.lv_dragonShireStarShrineEnabledImage[init_i1] = c_invalidDialogControlId;
    }
    libSCHO_gv_mMHOPanel.lv_beaconTopNeutral = c_invalidDialogControlId;
    libSCHO_gv_mMHOPanel.lv_beaconTopOrder = c_invalidDialogControlId;
    libSCHO_gv_mMHOPanel.lv_beaconTopChaos = c_invalidDialogControlId;
    libSCHO_gv_mMHOPanel.lv_beaconBottomNeutral = c_invalidDialogControlId;
    libSCHO_gv_mMHOPanel.lv_beaconBottomOrder = c_invalidDialogControlId;
    libSCHO_gv_mMHOPanel.lv_beaconBottomChaos = c_invalidDialogControlId;
    libSCHO_gv_mMHOPanel.lv_lightningLink1 = c_invalidDialogControlId;
    libSCHO_gv_mMHOPanel.lv_lightningLink2 = c_invalidDialogControlId;
    libSCHO_gv_mMHOPanel.lv_lightningLink3 = c_invalidDialogControlId;
    libSCHO_gv_mMHOPanel.lv_lightningLink4 = c_invalidDialogControlId;
    for (init_i1 = 0; init_i1 <= libCore_gv_bALMaxTeams; init_i1 += 1) {
        libSCHO_gv_mMHOPanel.lv_zergHudLeft[init_i1] = c_invalidDialogControlId;
    }
    for (init_i1 = 0; init_i1 <= libCore_gv_bALMaxTeams; init_i1 += 1) {
        libSCHO_gv_mMHOPanel.lv_zergHudRight[init_i1] = c_invalidDialogControlId;
    }
    for (init_i1 = 0; init_i1 <= libCore_gv_bALMaxTeams; init_i1 += 1) {
        libSCHO_gv_mMHOPanel.lv_alliedZergLabel[init_i1] = c_invalidDialogControlId;
    }
    for (init_i1 = 0; init_i1 <= libCore_gv_bALMaxTeams; init_i1 += 1) {
        libSCHO_gv_mMHOPanel.lv_enemyZergLabel[init_i1] = c_invalidDialogControlId;
    }
    for (init_i1 = 0; init_i1 <= libCore_gv_bALMaxTeams; init_i1 += 1) {
        libSCHO_gv_mMHOPanel.lv_beaconProgressLabel[init_i1] = c_invalidDialogControlId;
    }
    for (init_i1 = 0; init_i1 <= libCore_gv_bALMaxTeams; init_i1 += 1) {
        libSCHO_gv_mMHOPanel.lv_eggIconImageLeft[init_i1] = c_invalidDialogControlId;
    }
    for (init_i1 = 0; init_i1 <= libCore_gv_bALMaxTeams; init_i1 += 1) {
        libSCHO_gv_mMHOPanel.lv_eggIconImageRight[init_i1] = c_invalidDialogControlId;
    }
    libSCHO_gv_mMHOPanel.lv_beaconTopRadarWave = c_invalidDialogControlId;
    libSCHO_gv_mMHOPanel.lv_beaconBottomRadarWave = c_invalidDialogControlId;
    for (init_i = 0; init_i <= 2; init_i += 1) {
        libSCHO_gv_mMHO_EnemyZergIcon[init_i] = c_invalidPingId;
    }
    for (init_i = 0; init_i <= 2; init_i += 1) {
        libSCHO_gv_mMHO_AllyZergIcon[init_i] = c_invalidPingId;
    }
    for (init_i = 0; init_i <= 2; init_i += 1) {
        libSCHO_gv_mMHO_ObsZergPing[init_i] = c_invalidPingId;
    }
    for (init_i = 0; init_i <= libCore_gv_bALMaxTeams; init_i += 1) {
        libSCHO_gv_mMHO_ZergCurrentPathIndex[init_i] = 1;
    }
    for (init_i = 0; init_i <= libCore_gv_bALMaxTeams; init_i += 1) {
        libSCHO_gv_mMHO_ZergPathIndexMax[init_i] = 1;
    }
}

// Presets
// Functions
trigger auto_libSCHO_gf_MMHOEventWarningAnnouncement_Trigger = null;

void libSCHO_gf_MMHOEventWarningAnnouncement () {
    if (auto_libSCHO_gf_MMHOEventWarningAnnouncement_Trigger == null) {
        auto_libSCHO_gf_MMHOEventWarningAnnouncement_Trigger = TriggerCreate("auto_libSCHO_gf_MMHOEventWarningAnnouncement_TriggerFunc");
    }

    TriggerExecute(auto_libSCHO_gf_MMHOEventWarningAnnouncement_Trigger, false, false);
}

bool auto_libSCHO_gf_MMHOEventWarningAnnouncement_TriggerFunc (bool testConds, bool runActions) {
    // Variable Declarations
    point[3] lv_pingLocation;
    int lv_itTeam;

    // Automatic Variable Declarations
    const int auto6067E7AE_ae = libCore_gv_bALMaxTeams;
    const int auto6067E7AE_ai = 1;

    // Variable Initialization

    // Implementation
    if ((libSCHO_gv_mMHO_AttackLane == 1)) {
        lv_pingLocation[libGame_gv_teamOrderIndex_C] = libSCHO_gv_mMHO_Order_BottomHoldingPenPingPoint;
        lv_pingLocation[libGame_gv_teamChaosIndex_C] = libSCHO_gv_mMHO_Chaos_TopHoldingPenPingPoint;
    }
    else {
        lv_pingLocation[libGame_gv_teamOrderIndex_C] = libSCHO_gv_mMHO_Order_TopHoldingPenPingPoint;
        lv_pingLocation[libGame_gv_teamChaosIndex_C] = libSCHO_gv_mMHO_Chaos_BottomHoldingPenPingPoint;
    }
    lv_itTeam = 1;
    for ( ; ( (auto6067E7AE_ai >= 0 && lv_itTeam <= auto6067E7AE_ae) || (auto6067E7AE_ai < 0 && lv_itTeam >= auto6067E7AE_ae) ) ; lv_itTeam += auto6067E7AE_ai ) {
        libNtve_gf_CreateUnitsWithDefaultFacing(1, "ZergPathDummy", c_unitCreateIgnorePlacement, libGame_gf_ComputerPlayerInTeam(lv_itTeam), lv_pingLocation[lv_itTeam], null);
        libGame_gf_CalculateSpawnedMinionGoalPoints(lv_itTeam, lv_pingLocation[lv_itTeam]);
        libSCHO_gf_MMHOChangeZergMinimapIconsBasedOnZergHealth(lv_itTeam, UnitLastCreated());
        libAIAI_gf_MinionAIStartMinionAI(-1, UnitLastCreated(), libGame_gv_spawnedMinionLane, libGame_gv_spawnedMinionFirstWaypointIndex, true, false, true, 0, true);
        libSCHO_gv_mMHO_ZergIconUnit[lv_itTeam].lv_iconUnit = UnitLastCreated();
        if ((lv_itTeam == libGame_gv_teamOrderIndex_C)) {
            libCore_gf_CreateMinimapPingStorm(libGame_gf_PlayersOnTeamHeroes(lv_itTeam, false), "StormWarning", lv_pingLocation[lv_itTeam], Color(17.25, 25.49, 100.00), 5.0);
        }
        else {
            libCore_gf_CreateMinimapPingStorm(libGame_gf_PlayersOnTeamHeroes(libGame_gf_EnemyTeam(lv_itTeam), false), "StormWarning", lv_pingLocation[lv_itTeam], Color(100.00, 15.69, 18.04), 5.0);
        }
        libSCHO_gf_MMHOCreateZergPath(lv_itTeam, true);
    }
    return true;
}

void libSCHO_gf_MMHOInitializeHiveControlCapturePoints () {
    // Variable Declarations
    int lv_controlBeacons;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    lv_controlBeacons += 1;
    libNtve_gf_CreateUnitsWithDefaultFacing(1, "ZergHiveControlBeacon", c_unitCreateIgnorePlacement, libCore_gv_cOMPUTER_Neutral, libSCHO_gv_mMHO_TopCaptureBeacon, null);
    libSCHO_gv_beaconUnitTop = UnitLastCreated();
    libNtve_gf_SendActorMessageToUnit(libSCHO_gv_beaconUnitTop, "MinimapIcon Assets\\Textures\\storm_ui_minimapicon_beacon_right.dds");
    libSCHO_gv_mMHO_HiveControlBeacons[lv_controlBeacons].lv_beaconUnit = UnitLastCreated();
    libGame_gf_CapturePointCreate(UnitLastCreated(), libSCHO_gv_mMHO_CapturePointRadius_C, libSCHO_gv_mMHO_CapturePointCaptureTime_C, 0.0, libGame_ge_CapturePointDecay_DoNotDecay, libGame_ge_CapturePointDecay_Owner, true);
    libSCHO_gv_mMHO_HiveControlBeacons[lv_controlBeacons].lv_controlBeaconIndex = libGame_gf_LastCreatedCapturePoint();
    libGame_gf_CapturePointDisable(libGame_gf_LastCreatedCapturePoint());
    lv_controlBeacons += 1;
    libNtve_gf_CreateUnitsWithDefaultFacing(1, "ZergHiveControlBeacon", c_unitCreateIgnorePlacement, libCore_gv_cOMPUTER_Neutral, libSCHO_gv_mMHO_BottomCaptureBeacon, null);
    libSCHO_gv_beaconUnitBottom = UnitLastCreated();
    libNtve_gf_SendActorMessageToUnit(libSCHO_gv_beaconUnitBottom, "MinimapIcon Assets\\Textures\\storm_ui_minimapicon_beacon_left.dds");
    libSCHO_gv_mMHO_HiveControlBeacons[lv_controlBeacons].lv_beaconUnit = UnitLastCreated();
    libGame_gf_CapturePointCreate(UnitLastCreated(), libSCHO_gv_mMHO_CapturePointRadius_C, libSCHO_gv_mMHO_CapturePointCaptureTime_C, 0.0, libGame_ge_CapturePointDecay_DoNotDecay, libGame_ge_CapturePointDecay_Owner, true);
    libSCHO_gv_mMHO_HiveControlBeacons[lv_controlBeacons].lv_controlBeaconIndex = libGame_gf_LastCreatedCapturePoint();
    libGame_gf_CapturePointDisable(libGame_gf_LastCreatedCapturePoint());
}

void libSCHO_gf_MMHOCreateHiveControlPings () {
    // Variable Declarations
    int lv_itBeaconIndex;

    // Automatic Variable Declarations
    const int auto7DAC9428_ae = libSCHO_gv_mMHO_ControlBeaconMaxCount_C;
    const int auto7DAC9428_ai = 1;

    // Variable Initialization

    // Implementation
    lv_itBeaconIndex = 1;
    for ( ; ( (auto7DAC9428_ai >= 0 && lv_itBeaconIndex <= auto7DAC9428_ae) || (auto7DAC9428_ai < 0 && lv_itBeaconIndex >= auto7DAC9428_ae) ) ; lv_itBeaconIndex += auto7DAC9428_ai ) {
        libNtve_gf_CreatePingFacingAngleWithType(libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroup, "HoldoutBeaconCapturePointNeutralIcon", UnitGetPosition(libSCHO_gv_mMHO_HiveControlBeacons[lv_itBeaconIndex].lv_beaconUnit), ColorWithAlpha(0.00, 0.00, 0.00, 0.00), 0.0, UnitGetFacing(libSCHO_gv_mMHO_HiveControlBeacons[lv_itBeaconIndex].lv_beaconUnit), -1, -1);
        PingSetScale(PingLastCreated(), 0.1);
        libSCHO_gv_mMHO_HiveControlBeacons[lv_itBeaconIndex].lv_pingModelOrder = PingLastCreated();
        libNtve_gf_CreatePingFacingAngleWithType(libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroup, "HoldoutBeaconCapturePointNeutralIcon", UnitGetPosition(libSCHO_gv_mMHO_HiveControlBeacons[lv_itBeaconIndex].lv_beaconUnit), ColorWithAlpha(0.00, 0.00, 0.00, 0.00), 0.0, UnitGetFacing(libSCHO_gv_mMHO_HiveControlBeacons[lv_itBeaconIndex].lv_beaconUnit), -1, -1);
        PingSetScale(PingLastCreated(), 0.1);
        libSCHO_gv_mMHO_HiveControlBeacons[lv_itBeaconIndex].lv_pingModelChaos = PingLastCreated();
    }
}

void libSCHO_gf_MMHODestroyHiveControlPings () {
    // Variable Declarations
    int lv_controlBeacons;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    PingDestroy(libSCHO_gv_mMHO_HiveControlBeacons[1].lv_pingModelOrder);
    PingDestroy(libSCHO_gv_mMHO_HiveControlBeacons[1].lv_pingModelChaos);
    PingDestroy(libSCHO_gv_mMHO_HiveControlBeacons[2].lv_pingModelOrder);
    PingDestroy(libSCHO_gv_mMHO_HiveControlBeacons[2].lv_pingModelChaos);
}

void libSCHO_gf_MMHOHiveBeaconSpawnAnnouncement () {
    // Variable Declarations
    point lv_orderPingLocation;
    point lv_chaosPingLocation;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    libCore_gf_CreateMinimapPingStorm(PlayerGroupAll(), "StormWarning", libSCHO_gv_mMHO_TopCaptureBeacon, ColorWithAlpha(100.00, 100.00, 0.00, 0.00), 5.0);
    PingSetScale(PingLastCreated(), 0.5);
    libCore_gf_CreateMinimapPingStorm(PlayerGroupAll(), "StormWarning", libSCHO_gv_mMHO_BottomCaptureBeacon, ColorWithAlpha(100.00, 100.00, 0.00, 0.00), 5.0);
    PingSetScale(PingLastCreated(), 0.5);
    SoundPlayForPlayer(SoundLink("UI_Game_Ping_BraxisHoldout_BeaconsActivated", -1), c_maxPlayers, PlayerGroupAll(), 100.0, 0.0);
}

int libSCHO_gf_MMHOGetHiveControlBeaconOwners () {
    // Automatic Variable Declarations
    // Implementation
    if ((UnitGetOwner(libSCHO_gv_mMHO_HiveControlBeacons[1].lv_beaconUnit) == libCore_gv_cOMPUTER_TeamOrder) && (UnitGetOwner(libSCHO_gv_mMHO_HiveControlBeacons[2].lv_beaconUnit) == libCore_gv_cOMPUTER_TeamOrder)) {
        return libCore_gv_cOMPUTER_TeamOrder;
    }
    else if ((UnitGetOwner(libSCHO_gv_mMHO_HiveControlBeacons[1].lv_beaconUnit) == libCore_gv_cOMPUTER_TeamChaos) && (UnitGetOwner(libSCHO_gv_mMHO_HiveControlBeacons[2].lv_beaconUnit) == libCore_gv_cOMPUTER_TeamChaos)) {
        return libCore_gv_cOMPUTER_TeamChaos;
    }
    return libCore_gv_cOMPUTER_Neutral;
}

string libSCHO_gf_MMHOGetUserDataInstanceTier (int lp_team) {
    // Automatic Variable Declarations
    // Implementation
    if ((libSCHO_gv_mMHO_TeamProgress[lp_team] == 0.0)) {
        return "Tier1";
    }

    if ((libSCHO_gv_mMHO_TeamProgress[lp_team] < 21.0)) {
        return "Tier2";
    }

    if ((libSCHO_gv_mMHO_TeamProgress[lp_team] < 41.0)) {
        return "Tier3";
    }

    if ((libSCHO_gv_mMHO_TeamProgress[lp_team] < 61.0)) {
        return "Tier4";
    }

    if ((libSCHO_gv_mMHO_TeamProgress[lp_team] < 81.0)) {
        return "Tier5";
    }

    if ((libSCHO_gv_mMHO_TeamProgress[lp_team] < 100.0)) {
        return "Tier6";
    }

    if ((libSCHO_gv_mMHO_TeamProgress[lp_team] == 100.0)) {
        return "Tier7";
    }

    TextExpressionSetToken("Param/Expression/lib_SCHO_8950E107", "A", IntToText(lp_team));
    TextExpressionSetToken("Param/Expression/lib_SCHO_8950E107", "B", FixedToText(libAIAI_gv_aIDefenderCloseEnoughDistance, c_fixedPrecisionAny));
    TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_SCHO_8950E107"), true);
    return "Tier1";
}

void libSCHO_gf_MMHOTurnOnHiveControlBeacons () {
    // Variable Declarations
    int lv_index;

    // Automatic Variable Declarations
    const int auto78CE306E_ae = libSCHO_gv_mMHO_ControlBeaconMaxCount_C;
    const int auto78CE306E_ai = 1;

    // Variable Initialization

    // Implementation
    libSCHO_gv_mMHO_HiveControlBeaconEventActive = true;
    SoundPlayForPlayer(SoundLink("UI_Game_Ping_BraxisHoldout_BeaconsActivated", -1), c_maxPlayers, PlayerGroupAll(), 100.0, 0.0);
    libSCHO_gf_MMHOSpawnUltralisksForTeam(libGame_gv_teamOrderIndex_C);
    libSCHO_gf_MMHOSpawnUltralisksForTeam(libGame_gv_teamChaosIndex_C);
    libSCHO_gf_MMHOGrantFreeZergUnits(libGame_gv_teamOrderIndex_C);
    libSCHO_gf_MMHOGrantFreeZergUnits(libGame_gv_teamChaosIndex_C);
    lv_index = 1;
    for ( ; ( (auto78CE306E_ai >= 0 && lv_index <= auto78CE306E_ae) || (auto78CE306E_ai < 0 && lv_index >= auto78CE306E_ae) ) ; lv_index += auto78CE306E_ai ) {
        libGame_gf_CapturePointEnable(libSCHO_gv_mMHO_HiveControlBeacons[lv_index].lv_controlBeaconIndex);
        DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconTopNeutral, PlayerGroupAll(), true);
        DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconTopOrder, PlayerGroupAll(), false);
        DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconTopChaos, PlayerGroupAll(), false);
        DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconBottomNeutral, PlayerGroupAll(), true);
        DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconBottomOrder, PlayerGroupAll(), false);
        DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconBottomChaos, PlayerGroupAll(), false);
    }
    libSCHO_gf_MMHOControlSlabAnimationsEventStartStop(libSCHO_ge_MMHO_BeaconSignals_Start);
    libSCHO_gf_MMHOTurnOnOffAntenna(true);
}

void libSCHO_gf_MMHOHiveControlBeaconDoodadController (int lp_beaconIndex) {
    // Variable Declarations
    int lv_playerID;

    // Automatic Variable Declarations
    int auto7459CA2C_val;
    int auto5EA6CF18_val;
    int auto48DD1822_val;

    // Variable Initialization

    // Implementation
    lv_playerID = UnitGetOwner(libSCHO_gv_mMHO_HiveControlBeacons[lp_beaconIndex].lv_beaconUnit);
    auto7459CA2C_val = lp_beaconIndex;
    if (auto7459CA2C_val == libSCHO_gv_mMHO_TopBeaconIndex_C) {
        auto5EA6CF18_val = lv_playerID;
        if (auto5EA6CF18_val == libCore_gv_cOMPUTER_Neutral) {
            libCore_gf_SendActorMessageToDoodadsInRegion("SetPlayerId", libSCHO_gv_mMHO_TopBeaconOwnershipRegion, "Storm_Doodad_SCBraxis_CaptureSlab");
        }
        else if (auto5EA6CF18_val == libCore_gv_cOMPUTER_TeamOrder) {
            libCore_gf_SendActorMessageToDoodadsInRegion("SetPlayerId 11", libSCHO_gv_mMHO_TopBeaconOwnershipRegion, "Storm_Doodad_SCBraxis_CaptureSlab");
        }
        else if (auto5EA6CF18_val == libCore_gv_cOMPUTER_TeamChaos) {
            libCore_gf_SendActorMessageToDoodadsInRegion("SetPlayerId 12", libSCHO_gv_mMHO_TopBeaconOwnershipRegion, "Storm_Doodad_SCBraxis_CaptureSlab");
        }
        else {
        }
    }
    else if (auto7459CA2C_val == libSCHO_gv_mMHO_BottomBeaconIndex_C) {
        auto48DD1822_val = lv_playerID;
        if (auto48DD1822_val == libCore_gv_cOMPUTER_Neutral) {
            libCore_gf_SendActorMessageToDoodadsInRegion("SetPlayerId", libSCHO_gv_mMHO_BottomBeaconOwnershipRegion, "Storm_Doodad_SCBraxis_CaptureSlab");
        }
        else if (auto48DD1822_val == libCore_gv_cOMPUTER_TeamOrder) {
            libCore_gf_SendActorMessageToDoodadsInRegion("SetPlayerId 11", libSCHO_gv_mMHO_BottomBeaconOwnershipRegion, "Storm_Doodad_SCBraxis_CaptureSlab");
        }
        else if (auto48DD1822_val == libCore_gv_cOMPUTER_TeamChaos) {
            libCore_gf_SendActorMessageToDoodadsInRegion("SetPlayerId 12", libSCHO_gv_mMHO_BottomBeaconOwnershipRegion, "Storm_Doodad_SCBraxis_CaptureSlab");
        }
        else {
        }
    }
    else {
    }
}

void libSCHO_gf_MMHOHiveCageFullyCharged () {
    // Variable Declarations
    int lv_index;
    int lv_iTeam;

    // Automatic Variable Declarations
    const int auto9922165B_ae = libSCHO_gv_mMHO_ControlBeaconMaxCount_C;
    const int auto9922165B_ai = 1;
    const int auto9F884C16_ae = libCore_gv_bALMaxTeams;
    const int auto9F884C16_ai = 1;

    // Variable Initialization

    // Implementation
    libAIAI_gf_AITeamDelegateActivateDeactivateMapEvent(libAIAI_ge_AITeamDelegateActivateDeactivateMapToken_Deactivate);
    libAIAI_gf_AITeamDelegateActivateDeactivateMapReward(libAIAI_ge_AITeamDelegateActivateDeactivateMapToken_Activate);
    libAIAI_gf_AITeamDelegateResetMapEventProgressforTeam(libGame_gv_teamOrderIndex_C);
    libAIAI_gf_AITeamDelegateResetMapEventProgressforTeam(libGame_gv_teamChaosIndex_C);
    UnitBehaviorRemove(libSCHO_gv_mMHO_HiveCages[2].lv_south, "HoldingPenControllerActiveBR", 1);
    UnitBehaviorRemove(libSCHO_gv_mMHO_HiveCages[2].lv_north, "HoldingPenControllerActiveTR", 1);
    UnitBehaviorRemove(libSCHO_gv_mMHO_HiveCages[1].lv_north, "HoldingPenControllerActiveTL", 1);
    UnitBehaviorRemove(libSCHO_gv_mMHO_HiveCages[1].lv_south, "HoldingPenControllerActiveBL", 1);
    Wait(0.0625, c_timeGame);
    if ((libSCHO_gv_mMHO_AttackLaneHPMiniMapController == 1)) {
        UnitBehaviorAddPlayer(libSCHO_gv_mMHO_HiveCages[1].lv_north, "HoldingPenAnimation", libGame_gv_teamOrderIndex_C, 1);
        UnitBehaviorAddPlayer(libSCHO_gv_mMHO_HiveCages[2].lv_south, "HoldingPenAnimation", libGame_gv_teamChaosIndex_C, 1);
    }
    else {
        UnitBehaviorAddPlayer(libSCHO_gv_mMHO_HiveCages[2].lv_north, "HoldingPenAnimation", libGame_gv_teamChaosIndex_C, 1);
        UnitBehaviorAddPlayer(libSCHO_gv_mMHO_HiveCages[1].lv_south, "HoldingPenAnimation", libGame_gv_teamOrderIndex_C, 1);
    }
    UnitBehaviorRemove(libSCHO_gv_beaconUnitTop, "BeaconRadarWaveControllerTR", 1);
    UnitBehaviorRemove(libSCHO_gv_beaconUnitBottom, "BeaconRadarWaveControllerBR", 1);
    UnitBehaviorRemove(libSCHO_gv_beaconUnitBottom, "BeaconRadarWaveControllerBL", 1);
    UnitBehaviorRemove(libSCHO_gv_beaconUnitTop, "BeaconRadarWaveControllerTL", 1);
    lv_index = 1;
    for ( ; ( (auto9922165B_ai >= 0 && lv_index <= auto9922165B_ae) || (auto9922165B_ai < 0 && lv_index >= auto9922165B_ae) ) ; lv_index += auto9922165B_ai ) {
        libGame_gf_CapturePointDisable(libSCHO_gv_mMHO_HiveControlBeacons[lv_index].lv_controlBeaconIndex);
        libSCHO_gf_MMHOSetSwitchAnimationOwnershipChanges(libCore_gv_cOMPUTER_Neutral, lv_index);
        RemoveUnitOfInterest(libSCHO_gv_mMHO_HiveControlBeacons[lv_index].lv_beaconUnit, "Beacon", libNtve_ge_GoalTeam_Both);
    }
    libSCHO_gf_MMHOOpenCloseCaptureCages(true, libGame_gv_teamOrderIndex_C);
    libSCHO_gf_MMHOOpenCloseCaptureCages(true, libGame_gv_teamChaosIndex_C);
    DialogControlSendAnimationEvent(libSCHO_gv_mMHOPanel.lv_beaconProgressHPBarAnimFrame[1][1], PlayerGroupAll(), "FlashBars");
    DialogControlSendAnimationEvent(libSCHO_gv_mMHOPanel.lv_beaconProgressHPBarAnimFrame[1][2], PlayerGroupAll(), "FlashBars");
    DialogControlSendAnimationEvent(libSCHO_gv_mMHOPanel.lv_beaconProgressHPBarAnimFrame[2][1], PlayerGroupAll(), "FlashBars");
    DialogControlSendAnimationEvent(libSCHO_gv_mMHOPanel.lv_beaconProgressHPBarAnimFrame[2][2], PlayerGroupAll(), "FlashBars");
    Wait(2.0, c_timeGame);
    DialogControlSendAnimationEvent(libSCHO_gv_mMHOPanel.lv_beaconProgressHPBarAnimFrame[1][1], PlayerGroupAll(), "CaptureComplete");
    DialogControlSendAnimationEvent(libSCHO_gv_mMHOPanel.lv_beaconProgressHPBarAnimFrame[1][2], PlayerGroupAll(), "CaptureComplete");
    DialogControlSendAnimationEvent(libSCHO_gv_mMHOPanel.lv_beaconProgressHPBarAnimFrame[2][1], PlayerGroupAll(), "CaptureComplete");
    DialogControlSendAnimationEvent(libSCHO_gv_mMHOPanel.lv_beaconProgressHPBarAnimFrame[2][2], PlayerGroupAll(), "CaptureComplete");
    Wait(0.5, c_timeGame);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_zergHudLeft[1], libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroup, true);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_zergHudLeft[1], libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer], true);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_zergHudLeft[2], libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroup, true);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_zergHudRight[1], libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroup, true);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_zergHudRight[1], libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer], true);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_zergHudRight[2], libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroup, true);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_alliedZergLabel[1], libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroup, true);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_alliedZergLabel[1], libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer], true);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_alliedZergLabel[2], libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroup, true);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_enemyZergLabel[1], libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroup, true);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_enemyZergLabel[1], libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer], true);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_enemyZergLabel[2], libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroup, true);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconProgressLabel[1], libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroup, false);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconProgressLabel[1], libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer], false);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconProgressLabel[2], libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroup, false);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_eggIconImageLeft[1], libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroup, false);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_eggIconImageLeft[1], libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer], false);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_eggIconImageLeft[2], libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroup, false);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_eggIconImageRight[1], libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroup, false);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_eggIconImageRight[1], libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer], false);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_eggIconImageRight[2], libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroup, false);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconTopNeutral, PlayerGroupAll(), false);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconTopOrder, PlayerGroupAll(), false);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconTopChaos, PlayerGroupAll(), false);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconBottomNeutral, PlayerGroupAll(), false);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconBottomOrder, PlayerGroupAll(), false);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconBottomChaos, PlayerGroupAll(), false);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_lightningLink1, PlayerGroupAll(), false);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_lightningLink2, PlayerGroupAll(), false);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_lightningLink3, PlayerGroupAll(), false);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_lightningLink4, PlayerGroupAll(), false);
    libNtve_gf_SetDialogItemImage(libSCHO_gv_mMHOPanel.lv_beaconTopNeutral, "Assets\\Textures\\storm_ui_hud_minimap_holdout_beacon_top_off.dds", PlayerGroupAll());
    libNtve_gf_SetDialogItemImage(libSCHO_gv_mMHOPanel.lv_beaconTopOrder, "Assets\\Textures\\storm_ui_hud_minimap_holdout_beacon_top_off.dds", PlayerGroupAll());
    libNtve_gf_SetDialogItemImage(libSCHO_gv_mMHOPanel.lv_beaconTopChaos, "Assets\\Textures\\storm_ui_hud_minimap_holdout_beacon_top_off.dds", PlayerGroupAll());
    libNtve_gf_SetDialogItemImage(libSCHO_gv_mMHOPanel.lv_beaconBottomNeutral, "Assets\\Textures\\storm_ui_hud_minimap_holdout_beacon_bottom_off.dds", PlayerGroupAll());
    libNtve_gf_SetDialogItemImage(libSCHO_gv_mMHOPanel.lv_beaconBottomOrder, "Assets\\Textures\\storm_ui_hud_minimap_holdout_beacon_bottom_off.dds", PlayerGroupAll());
    libNtve_gf_SetDialogItemImage(libSCHO_gv_mMHOPanel.lv_beaconBottomChaos, "Assets\\Textures\\storm_ui_hud_minimap_holdout_beacon_bottom_off.dds", PlayerGroupAll());
    libNtve_gf_SendActorMessageToUnit(libSCHO_gv_mMHO_HiveCages[libGame_gv_teamOrderIndex_C].lv_south, "Signal BothBeaconsNoLongerCaptured");
    libNtve_gf_SendActorMessageToUnit(libSCHO_gv_mMHO_HiveCages[libGame_gv_teamChaosIndex_C].lv_south, "Signal BothBeaconsNoLongerCaptured");
    ActorSend(ActorFromDoodad(libSCHO_gv_mMHO_TopCaptureSlab), "Signal EventDoneResetOwnership");
    ActorSend(ActorFromDoodad(libSCHO_gv_mMHO_BottomCaptureSlab), "Signal EventDoneResetOwnership");
    libSCHO_gf_MMHOClearAlarmLights();
    libSCHO_gf_MMHOSetCableAnimationOwership(libCore_gv_cOMPUTER_Neutral);
    libSCHO_gf_MMHOTurnCaptureCablesOnOffForTeam(false, 0);
    libSCHO_gf_MMHOBothBeaconsNoLongerCapturedBeams();
    libSCHO_gf_MMHOTurnOnOffAntenna(false);
    libSCHO_gv_mMHO_TeamZergTier[libGame_gv_teamOrderIndex_C] = libSCHO_gf_MMHOGetUserDataInstanceTier(libGame_gv_teamOrderIndex_C);
    libSCHO_gv_mMHO_TeamZergTier[libGame_gv_teamChaosIndex_C] = libSCHO_gf_MMHOGetUserDataInstanceTier(libGame_gv_teamChaosIndex_C);
    StatEventCreate("BraxisHoldoutMapEventComplete");
    StatEventAddDataFixed(StatEventLastCreated(), "TeamOrderProgress", libSCHO_gv_mMHO_TeamProgress[libGame_gv_teamOrderIndex_C]);
    StatEventAddDataFixed(StatEventLastCreated(), "TeamChaosProgress", libSCHO_gv_mMHO_TeamProgress[libGame_gv_teamChaosIndex_C]);
    StatEventAddDataFixed(StatEventLastCreated(), "GameTime", libUIUI_gf_HeroesGameTime());
    StatEventSend(StatEventLastCreated());
    libSCHO_gf_MMHOEventWarningAnnouncement();
    libSond_gf_SoundtrackApplyNewDefaultSoundtrackForPlayerGroup("MX_BraxisHoldout_ZergReleased", libCore_gv_allHeroPlayersPlusObserver);
    libMapM_gf_JungleStartHibernateCamps();
    libSCHO_gf_MMHOCleanUpRemainingUltralisks();
    libSCHO_gf_MMHOControlSlabAnimationProgressReached100();
    Wait(1.5, c_timeGame);
    DialogControlSendAnimationEvent(libSCHO_gv_mMHOPanel.lv_beaconProgressHPBarAnimFrame[1][1], PlayerGroupAll(), "BarsReset");
    DialogControlSendAnimationEvent(libSCHO_gv_mMHOPanel.lv_beaconProgressHPBarAnimFrame[1][2], PlayerGroupAll(), "BarsReset");
    DialogControlSendAnimationEvent(libSCHO_gv_mMHOPanel.lv_beaconProgressHPBarAnimFrame[2][1], PlayerGroupAll(), "BarsReset");
    DialogControlSendAnimationEvent(libSCHO_gv_mMHOPanel.lv_beaconProgressHPBarAnimFrame[2][2], PlayerGroupAll(), "BarsReset");
    libSCHO_gf_MMHODetermineAttackWavePath(1);
    lv_index = 1;
    for ( ; ( (auto9F884C16_ai >= 0 && lv_index <= auto9F884C16_ae) || (auto9F884C16_ai < 0 && lv_index >= auto9F884C16_ae) ) ; lv_index += auto9F884C16_ai ) {
        UnitRemove(libSCHO_gv_mMHO_ZergIconUnit[lv_index].lv_iconUnit);
        libSCHO_gf_MMHOUpdateZergMinimapIcons(lv_index);
    }
    libSCHO_gf_MMHORemoveStasisBehaviorFromZerg();
    libSCHO_gf_MMHOCalculateZergTotalHP(true);
    libSCHO_gf_MMHOInitializeZergPath();
    libSCHO_gf_MMHOTransmissionZergAttacking();
    libSCHO_gf_MMHOZergAttackFinishedMonitorWait();
    libSCHO_gv_mMHO_WaveTracker = 1;
}

void libSCHO_gf_MMHOControlSlabAnimationsEventStartStop (int lp_startOrStop) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_startOrStop == libSCHO_ge_MMHO_BeaconSignals_Start)) {
        ActorSend(ActorFromDoodad(libSCHO_gv_mMHO_TopCaptureSlab), "Signal EventStart");
        ActorSend(ActorFromDoodad(libSCHO_gv_mMHO_BottomCaptureSlab), "Signal EventStart");
    }
    else {
        ActorSend(ActorFromDoodad(libSCHO_gv_mMHO_TopCaptureSlab), "Signal EventStop");
        ActorSend(ActorFromDoodad(libSCHO_gv_mMHO_BottomCaptureSlab), "Signal EventStop");
    }
}

void libSCHO_gf_MMHOControlSlabAnimationOwnershipChange (int lp_team, int lp_beaconIndex) {
    // Variable Declarations
    doodad lv_beacon;

    // Automatic Variable Declarations
    int auto12A50EA4_val;
    int autoE7EB559E_val;

    // Variable Initialization

    // Implementation
    auto12A50EA4_val = lp_beaconIndex;
    if (auto12A50EA4_val == libSCHO_gv_mMHO_TopBeaconIndex_C) {
        lv_beacon = libSCHO_gv_mMHO_TopCaptureSlab;
    }
    else if (auto12A50EA4_val == libSCHO_gv_mMHO_BottomBeaconIndex_C) {
        lv_beacon = libSCHO_gv_mMHO_BottomCaptureSlab;
    }
    else {
    }
    autoE7EB559E_val = lp_team;
    if (autoE7EB559E_val == libGame_gv_teamOrderIndex_C) {
        ActorSend(ActorFromDoodad(lv_beacon), "Signal BeaconCapturedOrder");
    }
    else if (autoE7EB559E_val == libGame_gv_teamChaosIndex_C) {
        ActorSend(ActorFromDoodad(lv_beacon), "Signal BeaconCapturedChaos");
    }
    else if (autoE7EB559E_val == libCore_gv_cOMPUTER_Neutral) {
        ActorSend(ActorFromDoodad(lv_beacon), "Signal BeaconCapturedNeutral");
    }
    else {
    }
}

void libSCHO_gf_MMHOControlSlabAnimationProgressReached100 () {
    // Automatic Variable Declarations
    // Implementation
    ActorSend(ActorFromDoodad(libSCHO_gv_mMHO_TopCaptureSlab), "Signal StageDone");
    ActorSend(ActorFromDoodad(libSCHO_gv_mMHO_BottomCaptureSlab), "Signal StageDone");
}

void libSCHO_gf_MMHOControlSlabAnimationsProgress (int lp_team) {
    // Variable Declarations
    string lv_teamString;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_teamString = "";

    // Implementation
    if ((lp_team == libGame_gv_teamOrderIndex_C)) {
        lv_teamString = "Order";
    }
    else {
        lv_teamString = "Chaos";
    }
    if ((libSCHO_gv_mMHO_TeamProgress[lp_team] == 0.0)) {
        ActorSend(ActorFromDoodad(libSCHO_gv_mMHO_TopCaptureSlab), (("Signal " + "Stage1" + lv_teamString)));
        ActorSend(ActorFromDoodad(libSCHO_gv_mMHO_BottomCaptureSlab), (("Signal " + "Stage1" + lv_teamString)));
    }
    else if ((libSCHO_gv_mMHO_TeamProgress[lp_team] == 34.0)) {
        ActorSend(ActorFromDoodad(libSCHO_gv_mMHO_TopCaptureSlab), (("Signal " + "Stage2" + lv_teamString)));
        ActorSend(ActorFromDoodad(libSCHO_gv_mMHO_BottomCaptureSlab), (("Signal " + "Stage2" + lv_teamString)));
    }
    else if ((libSCHO_gv_mMHO_TeamProgress[lp_team] == 66.0)) {
        ActorSend(ActorFromDoodad(libSCHO_gv_mMHO_TopCaptureSlab), (("Signal " + "Stage3" + lv_teamString)));
        ActorSend(ActorFromDoodad(libSCHO_gv_mMHO_BottomCaptureSlab), (("Signal " + "Stage3" + lv_teamString)));
    }
}

void libSCHO_gf_MMHOTurnOnOffAntenna (bool lp_onOff) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_onOff == true)) {
        libNtve_gf_SendActorMessageToUnit(libSCHO_gv_mMHO_BeaconAntennae.lv_north, "Signal EventStart");
        libNtve_gf_SendActorMessageToUnit(libSCHO_gv_mMHO_BeaconAntennae.lv_south, "Signal EventStart");
    }
    else {
        libNtve_gf_SendActorMessageToUnit(libSCHO_gv_mMHO_BeaconAntennae.lv_north, "Signal EventDone");
        libNtve_gf_SendActorMessageToUnit(libSCHO_gv_mMHO_BeaconAntennae.lv_south, "Signal EventDone");
    }
}

void libSCHO_gf_MMHOBothBeaconsCapturedBeams (int lp_team) {
    // Automatic Variable Declarations
    // Implementation
    UnitSetOwner(libSCHO_gv_mMHO_BeaconAntennae.lv_north, libGame_gf_ComputerPlayerInTeam(lp_team), true);
    UnitSetOwner(libSCHO_gv_mMHO_BeaconAntennae.lv_south, libGame_gf_ComputerPlayerInTeam(lp_team), true);
    if ((lp_team == 1) && (libSCHO_gv_mMHO_AttackLane == 1)) {
        libNtve_gf_SendActorMessageToUnit(libSCHO_gv_mMHO_BeaconAntennae.lv_south, "Signal LeftDown");
        libSCHO_gf_SetDownRoadArrowTeamColorAndAnimations(lp_team);
        ActorRegionCreate(null, "HoldoutBeamLoopRegion", libSCHO_gv_mMHO_HiveCages[libGame_gv_teamOrderIndex_C].lv_southSoundRegion);
        libSCHO_gv_mMHO_BeamSoundRegion = libNtve_gf_ActorLastCreated();
    }
    else if ((lp_team == 1) && (libSCHO_gv_mMHO_AttackLane == 2)) {
        libNtve_gf_SendActorMessageToUnit(libSCHO_gv_mMHO_BeaconAntennae.lv_north, "Signal LeftUp");
        libSCHO_gf_SetUpRoadArrowTeamColorAndAnimations(lp_team);
        ActorRegionCreate(null, "HoldoutBeamLoopRegion", libSCHO_gv_mMHO_HiveCages[libGame_gv_teamOrderIndex_C].lv_northSoundRegion);
        libSCHO_gv_mMHO_BeamSoundRegion = libNtve_gf_ActorLastCreated();
    }
    else if ((lp_team == 2) && (libSCHO_gv_mMHO_AttackLane == 1)) {
        libNtve_gf_SendActorMessageToUnit(libSCHO_gv_mMHO_BeaconAntennae.lv_north, "Signal RightUp");
        libSCHO_gf_SetUpRoadArrowTeamColorAndAnimations(lp_team);
        ActorRegionCreate(null, "HoldoutBeamLoopRegion", libSCHO_gv_mMHO_HiveCages[libGame_gv_teamChaosIndex_C].lv_northSoundRegion);
        libSCHO_gv_mMHO_BeamSoundRegion = libNtve_gf_ActorLastCreated();
    }
    else if ((lp_team == 2) && (libSCHO_gv_mMHO_AttackLane == 2)) {
        libNtve_gf_SendActorMessageToUnit(libSCHO_gv_mMHO_BeaconAntennae.lv_south, "Signal RightDown");
        libSCHO_gf_SetDownRoadArrowTeamColorAndAnimations(lp_team);
        ActorRegionCreate(null, "HoldoutBeamLoopRegion", libSCHO_gv_mMHO_HiveCages[libGame_gv_teamChaosIndex_C].lv_southSoundRegion);
        libSCHO_gv_mMHO_BeamSoundRegion = libNtve_gf_ActorLastCreated();
    }
}

void libSCHO_gf_MMHOBothBeaconsNoLongerCapturedBeams () {
    // Automatic Variable Declarations
    // Implementation
    UnitSetOwner(libSCHO_gv_mMHO_BeaconAntennae.lv_north, 0, true);
    UnitSetOwner(libSCHO_gv_mMHO_BeaconAntennae.lv_south, 0, true);
    UnitCreateEffectUnit(libSCHO_gv_mMHO_BeaconAntennae.lv_south, "CageAntennaActivateDestroyPersistent", libSCHO_gv_mMHO_BeaconAntennae.lv_south);
    UnitCreateEffectUnit(libSCHO_gv_mMHO_BeaconAntennae.lv_north, "CageAntennaActivateDestroyPersistent", libSCHO_gv_mMHO_BeaconAntennae.lv_north);
    UnitBehaviorAdd(libSCHO_gv_mMHO_BeaconAntennae.lv_north, "MapArrowDestroyBehavior", libSCHO_gv_mMHO_BeaconAntennae.lv_north, 1);
    UnitBehaviorAdd(libSCHO_gv_mMHO_BeaconAntennae.lv_south, "MapArrowDestroyBehavior", libSCHO_gv_mMHO_BeaconAntennae.lv_south, 1);
    UnitCreateEffectUnit(libSCHO_gv_mMHO_HiveCages[1].lv_north, "MapArrowDestroyPersistent", libSCHO_gv_mMHO_HiveCages[1].lv_north);
    UnitCreateEffectUnit(libSCHO_gv_mMHO_HiveCages[1].lv_south, "MapArrowDestroyPersistent", libSCHO_gv_mMHO_HiveCages[1].lv_south);
    UnitCreateEffectUnit(libSCHO_gv_mMHO_HiveCages[2].lv_north, "MapArrowDestroyPersistent", libSCHO_gv_mMHO_HiveCages[2].lv_north);
    UnitCreateEffectUnit(libSCHO_gv_mMHO_HiveCages[2].lv_south, "MapArrowDestroyPersistent", libSCHO_gv_mMHO_HiveCages[2].lv_south);
    libNtve_gf_SendActorMessageToUnit(libSCHO_gv_mMHO_BeaconAntennae.lv_north, "Signal BothBeaconsNoLongerCaptured");
    libNtve_gf_SendActorMessageToUnit(libSCHO_gv_mMHO_BeaconAntennae.lv_south, "Signal BothBeaconsNoLongerCaptured");
    libSCHO_gf_ClearRoadArrowVisualsAndTeamColor();
    ActorSend(libSCHO_gv_mMHO_BeamSoundRegion, "Signal StopSound");
}

void libSCHO_gf_SetUpRoadArrowTeamColorAndAnimations (int lp_team) {
    // Variable Declarations
    int lv_itDoodad;

    // Automatic Variable Declarations
    const int auto5359F7B6_ae = 10;
    const int auto5359F7B6_ai = 1;
    const int auto8D31EDBA_ae = 10;
    const int auto8D31EDBA_ai = 1;

    // Variable Initialization

    // Implementation
    if ((lp_team == libGame_gv_teamOrderIndex_C)) {
        lv_itDoodad = 1;
        for ( ; ( (auto8D31EDBA_ai >= 0 && lv_itDoodad <= auto8D31EDBA_ae) || (auto8D31EDBA_ai < 0 && lv_itDoodad >= auto8D31EDBA_ae) ) ; lv_itDoodad += auto8D31EDBA_ai ) {
            ActorSend(ActorFromDoodad(libSCHO_gv_mMHO_UpArrows[lv_itDoodad]), "Signal OwnerOrder");
        }
    }
    else {
        lv_itDoodad = 1;
        for ( ; ( (auto5359F7B6_ai >= 0 && lv_itDoodad <= auto5359F7B6_ae) || (auto5359F7B6_ai < 0 && lv_itDoodad >= auto5359F7B6_ae) ) ; lv_itDoodad += auto5359F7B6_ai ) {
            ActorSend(ActorFromDoodad(libSCHO_gv_mMHO_UpArrows[lv_itDoodad]), "Signal OwnerChaos");
        }
    }
}

void libSCHO_gf_SetDownRoadArrowTeamColorAndAnimations (int lp_team) {
    // Variable Declarations
    int lv_itDoodad;

    // Automatic Variable Declarations
    const int auto4AADA94D_ae = 10;
    const int auto4AADA94D_ai = 1;
    const int auto50A5E7BA_ae = 10;
    const int auto50A5E7BA_ai = 1;

    // Variable Initialization

    // Implementation
    if ((lp_team == libGame_gv_teamOrderIndex_C)) {
        lv_itDoodad = 1;
        for ( ; ( (auto50A5E7BA_ai >= 0 && lv_itDoodad <= auto50A5E7BA_ae) || (auto50A5E7BA_ai < 0 && lv_itDoodad >= auto50A5E7BA_ae) ) ; lv_itDoodad += auto50A5E7BA_ai ) {
            ActorSend(ActorFromDoodad(libSCHO_gv_mMHO_DownArrows[lv_itDoodad]), "Signal OwnerOrder");
        }
    }
    else {
        lv_itDoodad = 1;
        for ( ; ( (auto4AADA94D_ai >= 0 && lv_itDoodad <= auto4AADA94D_ae) || (auto4AADA94D_ai < 0 && lv_itDoodad >= auto4AADA94D_ae) ) ; lv_itDoodad += auto4AADA94D_ai ) {
            ActorSend(ActorFromDoodad(libSCHO_gv_mMHO_DownArrows[lv_itDoodad]), "Signal OwnerChaos");
        }
    }
}

void libSCHO_gf_ClearRoadArrowVisualsAndTeamColor () {
    // Variable Declarations
    int lv_itDoodad;

    // Automatic Variable Declarations
    const int auto42857288_ae = 10;
    const int auto42857288_ai = 1;
    const int auto0DB9331B_ae = 10;
    const int auto0DB9331B_ai = 1;

    // Variable Initialization

    // Implementation
    lv_itDoodad = 1;
    for ( ; ( (auto42857288_ai >= 0 && lv_itDoodad <= auto42857288_ae) || (auto42857288_ai < 0 && lv_itDoodad >= auto42857288_ae) ) ; lv_itDoodad += auto42857288_ai ) {
        ActorSend(ActorFromDoodad(libSCHO_gv_mMHO_DownArrows[lv_itDoodad]), "Signal Reset");
    }
    lv_itDoodad = 1;
    for ( ; ( (auto0DB9331B_ai >= 0 && lv_itDoodad <= auto0DB9331B_ae) || (auto0DB9331B_ai < 0 && lv_itDoodad >= auto0DB9331B_ae) ) ; lv_itDoodad += auto0DB9331B_ai ) {
        ActorSend(ActorFromDoodad(libSCHO_gv_mMHO_UpArrows[lv_itDoodad]), "Signal Reset");
    }
}

void libSCHO_gf_MMHOOpenCloseCaptureCages (bool lp_openClose, int lp_team) {
    // Variable Declarations
    unit lv_holdingCage;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    if ((lp_team == libGame_gv_teamOrderIndex_C)) {
        if ((libSCHO_gv_mMHO_AttackLane == 1)) {
            lv_holdingCage = libSCHO_gv_mMHO_HiveCages[1].lv_south;
        }
        else {
            lv_holdingCage = libSCHO_gv_mMHO_HiveCages[1].lv_north;
        }
    }
    else {
        if ((libSCHO_gv_mMHO_AttackLane == 2)) {
            lv_holdingCage = libSCHO_gv_mMHO_HiveCages[2].lv_south;
        }
        else {
            lv_holdingCage = libSCHO_gv_mMHO_HiveCages[2].lv_north;
        }
    }
    if ((lp_openClose == true)) {
        ActorSend(libNtve_gf_MainActorofUnit(lv_holdingCage), "Signal Open");
        if ((libSCHO_gv_mMHO_TeamProgress[lp_team] >= 100.0)) {
            ActorSend(libNtve_gf_MainActorofUnit(lv_holdingCage), "Signal OpenSoundWinningTeam");
        }
        else {
            ActorSend(libNtve_gf_MainActorofUnit(lv_holdingCage), "Signal OpenSoundLosingTeam");
        }
    }
    else {
        ActorSend(libNtve_gf_MainActorofUnit(lv_holdingCage), "Signal Close");
    }
}

void libSCHO_gf_MMHOOpenLeftRightUltraliskCages (int lp_team) {
    // Variable Declarations
    unit lv_holdingCage;
    unitgroup lv_unitGroup;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_unitGroup = UnitGroupEmpty();

    // Implementation
    if ((lp_team == libGame_gv_teamOrderIndex_C)) {
        lv_unitGroup = UnitGroupCopy(libSCHO_gv_mMHO_OrderUltralisks);
        if ((libSCHO_gv_mMHO_AttackLane == 1)) {
            lv_holdingCage = libSCHO_gv_mMHO_HiveCages[1].lv_south;
        }
        else {
            lv_holdingCage = libSCHO_gv_mMHO_HiveCages[1].lv_north;
        }
    }
    else {
        lv_unitGroup = UnitGroupCopy(libSCHO_gv_mMHO_ChaosUltralisks);
        if ((libSCHO_gv_mMHO_AttackLane == 2)) {
            lv_holdingCage = libSCHO_gv_mMHO_HiveCages[2].lv_south;
        }
        else {
            lv_holdingCage = libSCHO_gv_mMHO_HiveCages[2].lv_north;
        }
    }
    if ((UnitGroupCount(lv_unitGroup, c_unitCountAlive) == 2)) {
        ActorSend(libNtve_gf_MainActorofUnit(lv_holdingCage), "Signal OpenLeftGate");
    }
    else {
        ActorSend(libNtve_gf_MainActorofUnit(lv_holdingCage), "Signal OpenRightGate");
    }
}

void libSCHO_gf_MMHOSetCableAnimationOwership (int lp_team) {
    // Variable Declarations
    region lv_cableRegion;

    // Automatic Variable Declarations
    int auto5F0DAB81_val;

    // Variable Initialization

    // Implementation
    auto5F0DAB81_val = lp_team;
    if (auto5F0DAB81_val == libCore_gv_cOMPUTER_Neutral) {
        lv_cableRegion = libSCHO_gv_mMHO_TopCableRegion;
        libCore_gf_SendActorMessageToDoodadsInRegion("Signal Deactivate", lv_cableRegion, "Storm_Doodad_SCBraxis_Cables");
        lv_cableRegion = libSCHO_gv_mMHO_BottomCableRegion;
        libCore_gf_SendActorMessageToDoodadsInRegion("Signal Deactivate", lv_cableRegion, "Storm_Doodad_SCBraxis_Cables");
    }
    else if (auto5F0DAB81_val == libGame_gv_teamChaosIndex_C) {
        lv_cableRegion = libSCHO_gv_mMHO_TopCableRegion;
        libCore_gf_SendActorMessageToDoodadsInRegion("SetPlayerId 12", lv_cableRegion, "Storm_Doodad_SCBraxis_Cables");
        lv_cableRegion = libSCHO_gv_mMHO_BottomCableRegion;
        libCore_gf_SendActorMessageToDoodadsInRegion("SetPlayerId 12", lv_cableRegion, "Storm_Doodad_SCBraxis_Cables");
        if ((libSCHO_gv_mMHO_AttackLane == 1)) {
            lv_cableRegion = libSCHO_gv_mMHO_TopCableRegion;
            libCore_gf_SendActorMessageToDoodadsInRegion("Signal Up", lv_cableRegion, "Storm_Doodad_SCBraxis_Cables");
            libCore_gf_SendActorMessageToDoodadsInRegion("Signal Captured", lv_cableRegion, "Storm_Doodad_SCBraxis_Cables");
            libCore_gf_SendActorMessageToDoodadsInRegion("Signal Captured", libSCHO_gv_mMHO_BottomCableRegion, "Storm_Doodad_SCBraxis_Cables");
        }
        else {
            lv_cableRegion = libSCHO_gv_mMHO_BottomCableRegion;
            libCore_gf_SendActorMessageToDoodadsInRegion("Signal Down", lv_cableRegion, "Storm_Doodad_SCBraxis_Cables");
            libCore_gf_SendActorMessageToDoodadsInRegion("Signal Captured", lv_cableRegion, "Storm_Doodad_SCBraxis_Cables");
            libCore_gf_SendActorMessageToDoodadsInRegion("Signal Captured", libSCHO_gv_mMHO_TopCableRegion, "Storm_Doodad_SCBraxis_Cables");
        }
    }
    else if (auto5F0DAB81_val == libGame_gv_teamOrderIndex_C) {
        lv_cableRegion = libSCHO_gv_mMHO_TopCableRegion;
        libCore_gf_SendActorMessageToDoodadsInRegion("SetPlayerId 11", lv_cableRegion, "Storm_Doodad_SCBraxis_Cables");
        lv_cableRegion = libSCHO_gv_mMHO_BottomCableRegion;
        libCore_gf_SendActorMessageToDoodadsInRegion("SetPlayerId 11", lv_cableRegion, "Storm_Doodad_SCBraxis_Cables");
        if ((libSCHO_gv_mMHO_AttackLane == 1)) {
            lv_cableRegion = libSCHO_gv_mMHO_BottomCableRegion;
            libCore_gf_SendActorMessageToDoodadsInRegion("Signal Down", lv_cableRegion, "Storm_Doodad_SCBraxis_Cables");
            libCore_gf_SendActorMessageToDoodadsInRegion("Signal Captured", lv_cableRegion, "Storm_Doodad_SCBraxis_Cables");
            libCore_gf_SendActorMessageToDoodadsInRegion("Signal Captured", libSCHO_gv_mMHO_TopCableRegion, "Storm_Doodad_SCBraxis_Cables");
        }
        else {
            lv_cableRegion = libSCHO_gv_mMHO_TopCableRegion;
            libCore_gf_SendActorMessageToDoodadsInRegion("Signal Up", lv_cableRegion, "Storm_Doodad_SCBraxis_Cables");
            libCore_gf_SendActorMessageToDoodadsInRegion("Signal Captured", lv_cableRegion, "Storm_Doodad_SCBraxis_Cables");
            libCore_gf_SendActorMessageToDoodadsInRegion("Signal Captured", libSCHO_gv_mMHO_BottomCableRegion, "Storm_Doodad_SCBraxis_Cables");
        }
    }
    else {
    }
}

void libSCHO_gf_MMHOSetSwitchAnimationOwnershipChanges (int lp_team, int lp_beaconIndex) {
    // Variable Declarations
    region lv_topBeaconTopDoodadRegion;
    region lv_topBeaconBottomDoodadRegion;
    region lv_bottomBeaconTopDoodadRegion;
    region lv_bottomBeaconBottomDoodadRegion;
    doodad lv_beaconTopDoodad;
    doodad lv_beaconBottomDoodad;

    // Automatic Variable Declarations
    int auto03FE1B7A_val;

    // Variable Initialization

    // Implementation
    if ((lp_beaconIndex == 1)) {
        lv_beaconTopDoodad = libSCHO_gv_mMHO_TopBeaconTopArrow;
        lv_beaconBottomDoodad = libSCHO_gv_mMHO_TopBeaconBottomArrow;
    }
    else {
        lv_beaconTopDoodad = libSCHO_gv_mMHO_BottomBeaconTopArrow;
        lv_beaconBottomDoodad = libSCHO_gv_mMHO_BottomBeaconBottomArrow;
    }
    auto03FE1B7A_val = lp_team;
    if (auto03FE1B7A_val == libCore_gv_cOMPUTER_Neutral) {
        ActorSend(ActorFromDoodad(lv_beaconTopDoodad), "Signal Deactivate");
        ActorSend(ActorFromDoodad(lv_beaconBottomDoodad), "Signal Deactivate");
    }
    else if (auto03FE1B7A_val == libGame_gv_teamChaosIndex_C) {
        ActorSend(ActorFromDoodad(lv_beaconTopDoodad), "SetPlayerId 12");
        ActorSend(ActorFromDoodad(lv_beaconBottomDoodad), "SetPlayerId 12");
        if ((libSCHO_gv_mMHO_AttackLane == 1)) {
            ActorSend(ActorFromDoodad(lv_beaconTopDoodad), "Signal OneCaptured");
        }
        else {
            ActorSend(ActorFromDoodad(lv_beaconBottomDoodad), "Signal OneCaptured");
        }
    }
    else if (auto03FE1B7A_val == libGame_gv_teamOrderIndex_C) {
        ActorSend(ActorFromDoodad(lv_beaconTopDoodad), "SetPlayerId 11");
        ActorSend(ActorFromDoodad(lv_beaconBottomDoodad), "SetPlayerId 11");
        if ((libSCHO_gv_mMHO_AttackLane == 1)) {
            ActorSend(ActorFromDoodad(lv_beaconBottomDoodad), "Signal OneCaptured");
        }
        else {
            ActorSend(ActorFromDoodad(lv_beaconTopDoodad), "Signal OneCaptured");
        }
    }
    else {
    }
}

void libSCHO_gf_MMHOSetSwitchAnimationBothBeaconsCaptured (int lp_team) {
    // Variable Declarations
    region lv_topBeaconTopDoodadRegion;
    region lv_topBeaconBottomDoodadRegion;
    region lv_bottomBeaconTopDoodadRegion;
    region lv_bottomBeaconBottomDoodadRegion;
    doodad lv_beaconTopDoodad;
    doodad lv_beaconBottomDoodad;

    // Automatic Variable Declarations
    int autoDCEADE20_val;

    // Variable Initialization

    // Implementation
    autoDCEADE20_val = lp_team;
    if (autoDCEADE20_val == libGame_gv_teamChaosIndex_C) {
        if ((libSCHO_gv_mMHO_AttackLane == 1)) {
            lv_beaconTopDoodad = libSCHO_gv_mMHO_TopBeaconTopArrow;
            lv_beaconBottomDoodad = libSCHO_gv_mMHO_BottomBeaconTopArrow;
        }
        else {
            lv_beaconTopDoodad = libSCHO_gv_mMHO_TopBeaconBottomArrow;
            lv_beaconBottomDoodad = libSCHO_gv_mMHO_BottomBeaconBottomArrow;
        }
        ActorSend(ActorFromDoodad(lv_beaconTopDoodad), "SetPlayerId 12");
        ActorSend(ActorFromDoodad(lv_beaconBottomDoodad), "SetPlayerId 12");
        ActorSend(ActorFromDoodad(lv_beaconTopDoodad), "Signal TwoCaptured");
        ActorSend(ActorFromDoodad(lv_beaconBottomDoodad), "Signal TwoCaptured");
    }
    else if (autoDCEADE20_val == libGame_gv_teamOrderIndex_C) {
        if ((libSCHO_gv_mMHO_AttackLane == 1)) {
            lv_beaconTopDoodad = libSCHO_gv_mMHO_TopBeaconBottomArrow;
            lv_beaconBottomDoodad = libSCHO_gv_mMHO_BottomBeaconBottomArrow;
        }
        else {
            lv_beaconTopDoodad = libSCHO_gv_mMHO_TopBeaconTopArrow;
            lv_beaconBottomDoodad = libSCHO_gv_mMHO_BottomBeaconTopArrow;
        }
        ActorSend(ActorFromDoodad(lv_beaconTopDoodad), "SetPlayerId 11");
        ActorSend(ActorFromDoodad(lv_beaconBottomDoodad), "SetPlayerId 11");
        ActorSend(ActorFromDoodad(lv_beaconTopDoodad), "Signal TwoCaptured");
        ActorSend(ActorFromDoodad(lv_beaconBottomDoodad), "Signal TwoCaptured");
    }
    else {
    }
}

void libSCHO_gf_MMHOSetSwitchAnimationBothBeaconsNoLongerCaptured () {
    // Variable Declarations
    region lv_topBeaconTopDoodadRegion;
    region lv_topBeaconBottomDoodadRegion;
    region lv_bottomBeaconTopDoodadRegion;
    region lv_bottomBeaconBottomDoodadRegion;
    doodad lv_beaconTopDoodad;
    doodad lv_beaconBottomDoodad;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    lv_beaconTopDoodad = libSCHO_gv_mMHO_TopBeaconTopArrow;
    lv_beaconBottomDoodad = libSCHO_gv_mMHO_TopBeaconBottomArrow;
    ActorSend(ActorFromDoodad(lv_beaconTopDoodad), "Signal SingleShrine");
    ActorSend(ActorFromDoodad(lv_beaconBottomDoodad), "Signal SingleShrine");
    if ((UnitGetOwner(libSCHO_gv_mMHO_HiveControlBeacons[1].lv_beaconUnit) == libCore_gv_cOMPUTER_Neutral)) {
        ActorSend(ActorFromDoodad(lv_beaconTopDoodad), "ClearTeamColor");
        ActorSend(ActorFromDoodad(lv_beaconBottomDoodad), "ClearTeamColor");
    }

    lv_beaconTopDoodad = libSCHO_gv_mMHO_BottomBeaconTopArrow;
    lv_beaconBottomDoodad = libSCHO_gv_mMHO_BottomBeaconBottomArrow;
    ActorSend(ActorFromDoodad(lv_beaconTopDoodad), "Signal SingleShrine");
    ActorSend(ActorFromDoodad(lv_beaconBottomDoodad), "Signal SingleShrine");
    if ((UnitGetOwner(libSCHO_gv_mMHO_HiveControlBeacons[2].lv_beaconUnit) == libCore_gv_cOMPUTER_Neutral)) {
        ActorSend(ActorFromDoodad(lv_beaconTopDoodad), "ClearTeamColor");
        ActorSend(ActorFromDoodad(lv_beaconBottomDoodad), "ClearTeamColor");
    }

}

void libSCHO_gf_MMHOTurnCaptureCablesOnOffForTeam (bool lp_onOff, int lp_team) {
    // Variable Declarations
    int lv_i;
    string lv_orientationSignal;
    string lv_teamSignal;

    // Automatic Variable Declarations
    const int auto0809A7D0_ae = 6;
    const int auto0809A7D0_ai = 1;
    const int auto97B2FE55_ae = 6;
    const int auto97B2FE55_ai = 1;

    // Variable Initialization
    lv_orientationSignal = "";
    lv_teamSignal = "";

    // Implementation
    if ((lp_onOff == true)) {
        if ((lp_team == libGame_gv_teamOrderIndex_C)) {
            lv_teamSignal = "Signal Order";
            lv_orientationSignal = "Signal Down";
            if ((libSCHO_gv_mMHO_AttackLane == 1)) {
                lv_orientationSignal = "Signal Down";
            }
            else {
                lv_orientationSignal = "Signal Up";
            }
        }
        else {
            lv_teamSignal = "Signal Chaos";
            if ((libSCHO_gv_mMHO_AttackLane == 1)) {
                lv_orientationSignal = "Signal Up";
            }
            else {
                lv_orientationSignal = "Signal Down";
            }
        }
        lv_i = 1;
        for ( ; ( (auto97B2FE55_ai >= 0 && lv_i <= auto97B2FE55_ae) || (auto97B2FE55_ai < 0 && lv_i >= auto97B2FE55_ae) ) ; lv_i += auto97B2FE55_ai ) {
            ActorSend(ActorFromDoodad(libSCHO_gv_mMHO_CaptureCables[lv_i]), (lv_teamSignal));
            ActorSend(ActorFromDoodad(libSCHO_gv_mMHO_CaptureCables[lv_i]), (lv_orientationSignal));
        }
    }
    else {
        lv_i = 1;
        for ( ; ( (auto0809A7D0_ai >= 0 && lv_i <= auto0809A7D0_ae) || (auto0809A7D0_ai < 0 && lv_i >= auto0809A7D0_ae) ) ; lv_i += auto0809A7D0_ai ) {
            ActorSend(ActorFromDoodad(libSCHO_gv_mMHO_CaptureCables[lv_i]), "Signal Off");
        }
    }
}

void libSCHO_gf_MMHOTurnOnAlarmLightsForTeam (int lp_team) {
    // Variable Declarations
    int lv_itDoodad;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    if ((lp_team == libGame_gv_teamOrderIndex_C)) {
        ActorSend(libMapM_gv_mapMechanicControllerActor, "Signal AlarmOwnerOrder");
    }
    else {
        ActorSend(libMapM_gv_mapMechanicControllerActor, "Signal AlarmOwnerChaos");
    }
}

void libSCHO_gf_MMHOClearAlarmLights () {
    // Variable Declarations
    int lv_itDoodad;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    ActorSend(libMapM_gv_mapMechanicControllerActor, "Signal AlarmClearOwner");
}

trigger auto_libSCHO_gf_MakeSCVUnitsMoveAround_Trigger = null;
unit auto_libSCHO_gf_MakeSCVUnitsMoveAround_lp_sCV1;
unit auto_libSCHO_gf_MakeSCVUnitsMoveAround_lp_sCV2;
unit auto_libSCHO_gf_MakeSCVUnitsMoveAround_lp_sCV3;
point auto_libSCHO_gf_MakeSCVUnitsMoveAround_lp_turnInPoint;
point auto_libSCHO_gf_MakeSCVUnitsMoveAround_lp_mineralPatch1;
point auto_libSCHO_gf_MakeSCVUnitsMoveAround_lp_mineralPatch2;
point auto_libSCHO_gf_MakeSCVUnitsMoveAround_lp_mineralPatch3;

void libSCHO_gf_MakeSCVUnitsMoveAround (unit lp_sCV1, unit lp_sCV2, unit lp_sCV3, point lp_turnInPoint, point lp_mineralPatch1, point lp_mineralPatch2, point lp_mineralPatch3) {
    auto_libSCHO_gf_MakeSCVUnitsMoveAround_lp_sCV1 = lp_sCV1;
    auto_libSCHO_gf_MakeSCVUnitsMoveAround_lp_sCV2 = lp_sCV2;
    auto_libSCHO_gf_MakeSCVUnitsMoveAround_lp_sCV3 = lp_sCV3;
    auto_libSCHO_gf_MakeSCVUnitsMoveAround_lp_turnInPoint = lp_turnInPoint;
    auto_libSCHO_gf_MakeSCVUnitsMoveAround_lp_mineralPatch1 = lp_mineralPatch1;
    auto_libSCHO_gf_MakeSCVUnitsMoveAround_lp_mineralPatch2 = lp_mineralPatch2;
    auto_libSCHO_gf_MakeSCVUnitsMoveAround_lp_mineralPatch3 = lp_mineralPatch3;

    if (auto_libSCHO_gf_MakeSCVUnitsMoveAround_Trigger == null) {
        auto_libSCHO_gf_MakeSCVUnitsMoveAround_Trigger = TriggerCreate("auto_libSCHO_gf_MakeSCVUnitsMoveAround_TriggerFunc");
    }

    TriggerExecute(auto_libSCHO_gf_MakeSCVUnitsMoveAround_Trigger, false, false);
}

bool auto_libSCHO_gf_MakeSCVUnitsMoveAround_TriggerFunc (bool testConds, bool runActions) {
    unit lp_sCV1 = auto_libSCHO_gf_MakeSCVUnitsMoveAround_lp_sCV1;
    unit lp_sCV2 = auto_libSCHO_gf_MakeSCVUnitsMoveAround_lp_sCV2;
    unit lp_sCV3 = auto_libSCHO_gf_MakeSCVUnitsMoveAround_lp_sCV3;
    point lp_turnInPoint = auto_libSCHO_gf_MakeSCVUnitsMoveAround_lp_turnInPoint;
    point lp_mineralPatch1 = auto_libSCHO_gf_MakeSCVUnitsMoveAround_lp_mineralPatch1;
    point lp_mineralPatch2 = auto_libSCHO_gf_MakeSCVUnitsMoveAround_lp_mineralPatch2;
    point lp_mineralPatch3 = auto_libSCHO_gf_MakeSCVUnitsMoveAround_lp_mineralPatch3;

    // Variable Declarations
    unitgroup lv_sCVUnitGroup;
    unit lv_lastSCVToMove;
    unit lv_unitToMove;
    point lv_destinationPoint;
    point lv_returnPoint;

    // Automatic Variable Declarations
    unit auto6E847259_val;
    unit auto8210FB56_val;

    // Variable Initialization
    lv_sCVUnitGroup = UnitGroupEmpty();

    // Implementation
    UnitGroupAdd(lv_sCVUnitGroup, lp_sCV1);
    UnitGroupAdd(lv_sCVUnitGroup, lp_sCV2);
    UnitGroupAdd(lv_sCVUnitGroup, lp_sCV3);
    lv_destinationPoint = lp_turnInPoint;
    while (true) {
        lv_unitToMove = UnitGroupRandomUnit(lv_sCVUnitGroup, c_unitCountAlive);
        if ((lv_unitToMove == lv_lastSCVToMove)) {
            auto6E847259_val = lv_unitToMove;
            if (auto6E847259_val == lp_sCV1) {
                UnitGroupRemove(lv_sCVUnitGroup, lp_sCV1);
                lv_unitToMove = UnitGroupRandomUnit(lv_sCVUnitGroup, c_unitCountAlive);
                UnitGroupAdd(lv_sCVUnitGroup, lp_sCV1);
            }
            else if (auto6E847259_val == lp_sCV2) {
                UnitGroupRemove(lv_sCVUnitGroup, lp_sCV2);
                lv_unitToMove = UnitGroupRandomUnit(lv_sCVUnitGroup, c_unitCountAlive);
                UnitGroupAdd(lv_sCVUnitGroup, lp_sCV2);
            }
            else if (auto6E847259_val == lp_sCV3) {
                UnitGroupRemove(lv_sCVUnitGroup, lp_sCV3);
                lv_unitToMove = UnitGroupRandomUnit(lv_sCVUnitGroup, c_unitCountAlive);
                UnitGroupAdd(lv_sCVUnitGroup, lp_sCV3);
            }
            else {
            }
        }

        lv_lastSCVToMove = lv_unitToMove;
        auto8210FB56_val = lv_unitToMove;
        if (auto8210FB56_val == lp_sCV1) {
            lv_returnPoint = lp_mineralPatch1;
        }
        else if (auto8210FB56_val == lp_sCV2) {
            lv_returnPoint = lp_mineralPatch2;
        }
        else if (auto8210FB56_val == lp_sCV3) {
            lv_returnPoint = lp_mineralPatch3;
        }
        else {
        }
        UnitIssueOrder(lv_unitToMove, OrderTargetingPoint(AbilityCommand("BraxisHoldoutSCVChannel", 0), lv_destinationPoint), c_orderQueueReplace);
        UnitIssueOrder(lv_unitToMove, OrderTargetingPoint(AbilityCommand("BraxisHoldoutSCVChannel", 0), lv_returnPoint), c_orderQueueAddToEnd);
        Wait(RandomFixed(5.0, 10.0), c_timeGame);
    }
    return true;
}

void libSCHO_gf_MMHODetermineAttackWavePath (int lp_waveIndex) {
    // Automatic Variable Declarations
    // Implementation
    if ((libSCHO_gv_mMHO_AttackLane == 1)) {
        libSCHO_gf_MMHOAttackWavePath(libSCHO_gv_mMHO_AttackGroups[libGame_gv_teamChaosIndex_C][lp_waveIndex], libSCHO_gv_mMHO_AttackGroups[libGame_gv_teamOrderIndex_C][lp_waveIndex]);
    }
    else {
        libSCHO_gf_MMHOAttackWavePath(libSCHO_gv_mMHO_AttackGroups[libGame_gv_teamOrderIndex_C][lp_waveIndex], libSCHO_gv_mMHO_AttackGroups[libGame_gv_teamChaosIndex_C][lp_waveIndex]);
    }
    libSCHO_gf_MMHOTeleportStuckZergFailsafe(lp_waveIndex);
}

trigger auto_libSCHO_gf_MMHOTeleportStuckZergFailsafe_Trigger = null;
int auto_libSCHO_gf_MMHOTeleportStuckZergFailsafe_lp_waveIndex;

void libSCHO_gf_MMHOTeleportStuckZergFailsafe (int lp_waveIndex) {
    auto_libSCHO_gf_MMHOTeleportStuckZergFailsafe_lp_waveIndex = lp_waveIndex;

    if (auto_libSCHO_gf_MMHOTeleportStuckZergFailsafe_Trigger == null) {
        auto_libSCHO_gf_MMHOTeleportStuckZergFailsafe_Trigger = TriggerCreate("auto_libSCHO_gf_MMHOTeleportStuckZergFailsafe_TriggerFunc");
    }

    TriggerExecute(auto_libSCHO_gf_MMHOTeleportStuckZergFailsafe_Trigger, false, false);
}

bool auto_libSCHO_gf_MMHOTeleportStuckZergFailsafe_TriggerFunc (bool testConds, bool runActions) {
    int lp_waveIndex = auto_libSCHO_gf_MMHOTeleportStuckZergFailsafe_lp_waveIndex;

    // Variable Declarations
    int lv_itUnit;
    int lv_player;

    // Automatic Variable Declarations
    unitgroup autoADD67D88_g;
    int autoADD67D88_u;
    unit autoADD67D88_var;
    unitgroup auto1B3E2CBB_g;
    int auto1B3E2CBB_u;
    unit auto1B3E2CBB_var;
    unitgroup autoCCA4D170_g;
    int autoCCA4D170_u;
    unit autoCCA4D170_var;
    unitgroup auto1C75291D_g;
    int auto1C75291D_u;
    unit auto1C75291D_var;
    unitgroup auto1E5C2F55_g;
    int auto1E5C2F55_u;
    unit auto1E5C2F55_var;
    unitgroup auto66B9FCA0_g;
    int auto66B9FCA0_u;
    unit auto66B9FCA0_var;
    unitgroup autoC59DED3F_g;
    int autoC59DED3F_u;
    unit autoC59DED3F_var;
    unitgroup auto22465BFF_g;
    int auto22465BFF_u;
    unit auto22465BFF_var;
    unitgroup auto96286027_g;
    int auto96286027_u;
    unit auto96286027_var;
    unitgroup auto9EF49945_g;
    int auto9EF49945_u;
    unit auto9EF49945_var;
    unitgroup auto19E1BCEE_g;
    int auto19E1BCEE_u;
    unit auto19E1BCEE_var;
    unitgroup auto7425BE1B_g;
    int auto7425BE1B_u;
    unit auto7425BE1B_var;
    unitgroup auto469E80AA_g;
    int auto469E80AA_u;
    unit auto469E80AA_var;
    unitgroup auto1109E43A_g;
    int auto1109E43A_u;
    unit auto1109E43A_var;
    unitgroup autoB951F474_g;
    int autoB951F474_u;
    unit autoB951F474_var;
    unitgroup auto73A91A0D_g;
    int auto73A91A0D_u;
    unit auto73A91A0D_var;
    unitgroup autoE63DF2EA_g;
    int autoE63DF2EA_u;
    unit autoE63DF2EA_var;
    unitgroup auto63B56D8F_g;
    int auto63B56D8F_u;
    unit auto63B56D8F_var;
    unitgroup auto45FE1551_g;
    int auto45FE1551_u;
    unit auto45FE1551_var;
    unitgroup autoDA226475_g;
    int autoDA226475_u;
    unit autoDA226475_var;

    // Variable Initialization

    // Implementation
    Wait(30.0, c_timeGame);
    if ((libSCHO_gv_mMHO_AttackLane == 1)) {
        auto19E1BCEE_g = UnitGroup("ZergZergling", libStEx_gv_pLAYER_11_ORDER, RegionCircle(RegionGetCenter(libSCHO_gv_mMHO_Order_BottomHoldingPenRegion), 20.0), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
        auto19E1BCEE_u = UnitGroupCount(auto19E1BCEE_g, c_unitCountAll);
        for (;; auto19E1BCEE_u -= 1) {
            auto19E1BCEE_var = UnitGroupUnitFromEnd(auto19E1BCEE_g, auto19E1BCEE_u);
            if (auto19E1BCEE_var == null) { break; }
            libStEx_gf_MoveUnit(auto19E1BCEE_var, RegionGetCenter(libSCHO_gv_mMHO_Order_BottomHoldingPenRegion), true);
        }
        auto7425BE1B_g = UnitGroup("ZergBaneling", libStEx_gv_pLAYER_11_ORDER, RegionCircle(RegionGetCenter(libSCHO_gv_mMHO_Order_BottomHoldingPenRegion), 20.0), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
        auto7425BE1B_u = UnitGroupCount(auto7425BE1B_g, c_unitCountAll);
        for (;; auto7425BE1B_u -= 1) {
            auto7425BE1B_var = UnitGroupUnitFromEnd(auto7425BE1B_g, auto7425BE1B_u);
            if (auto7425BE1B_var == null) { break; }
            libStEx_gf_MoveUnit(auto7425BE1B_var, RegionGetCenter(libSCHO_gv_mMHO_Order_BottomHoldingPenRegion), true);
        }
        auto469E80AA_g = UnitGroup("ZergHydralisk", libStEx_gv_pLAYER_11_ORDER, RegionCircle(RegionGetCenter(libSCHO_gv_mMHO_Order_BottomHoldingPenRegion), 20.0), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
        auto469E80AA_u = UnitGroupCount(auto469E80AA_g, c_unitCountAll);
        for (;; auto469E80AA_u -= 1) {
            auto469E80AA_var = UnitGroupUnitFromEnd(auto469E80AA_g, auto469E80AA_u);
            if (auto469E80AA_var == null) { break; }
            libStEx_gf_MoveUnit(auto469E80AA_var, RegionGetCenter(libSCHO_gv_mMHO_Order_BottomHoldingPenRegion), true);
        }
        auto1109E43A_g = UnitGroup("ZergUltralisk", libStEx_gv_pLAYER_11_ORDER, RegionCircle(RegionGetCenter(libSCHO_gv_mMHO_Order_BottomHoldingPenRegion), 20.0), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
        auto1109E43A_u = UnitGroupCount(auto1109E43A_g, c_unitCountAll);
        for (;; auto1109E43A_u -= 1) {
            auto1109E43A_var = UnitGroupUnitFromEnd(auto1109E43A_g, auto1109E43A_u);
            if (auto1109E43A_var == null) { break; }
            libStEx_gf_MoveUnit(auto1109E43A_var, RegionGetCenter(libSCHO_gv_mMHO_Order_BottomHoldingPenRegion), true);
        }
        autoB951F474_g = UnitGroup("ZergGuardian", libStEx_gv_pLAYER_11_ORDER, RegionCircle(RegionGetCenter(libSCHO_gv_mMHO_Order_BottomHoldingPenRegion), 20.0), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
        autoB951F474_u = UnitGroupCount(autoB951F474_g, c_unitCountAll);
        for (;; autoB951F474_u -= 1) {
            autoB951F474_var = UnitGroupUnitFromEnd(autoB951F474_g, autoB951F474_u);
            if (autoB951F474_var == null) { break; }
            libStEx_gf_MoveUnit(autoB951F474_var, RegionGetCenter(libSCHO_gv_mMHO_Order_BottomHoldingPenRegion), true);
        }
        auto73A91A0D_g = UnitGroup("ZergZergling", libStEx_gv_pLAYER_12_CHAOS, RegionCircle(RegionGetCenter(libSCHO_gv_mMHO_Chaos_TopHoldingPenRegion), 20.0), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
        auto73A91A0D_u = UnitGroupCount(auto73A91A0D_g, c_unitCountAll);
        for (;; auto73A91A0D_u -= 1) {
            auto73A91A0D_var = UnitGroupUnitFromEnd(auto73A91A0D_g, auto73A91A0D_u);
            if (auto73A91A0D_var == null) { break; }
            libStEx_gf_MoveUnit(auto73A91A0D_var, RegionGetCenter(libSCHO_gv_mMHO_Chaos_TopHoldingPenRegion), true);
        }
        autoE63DF2EA_g = UnitGroup("ZergBaneling", libStEx_gv_pLAYER_12_CHAOS, RegionCircle(RegionGetCenter(libSCHO_gv_mMHO_Chaos_TopHoldingPenRegion), 20.0), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
        autoE63DF2EA_u = UnitGroupCount(autoE63DF2EA_g, c_unitCountAll);
        for (;; autoE63DF2EA_u -= 1) {
            autoE63DF2EA_var = UnitGroupUnitFromEnd(autoE63DF2EA_g, autoE63DF2EA_u);
            if (autoE63DF2EA_var == null) { break; }
            libStEx_gf_MoveUnit(autoE63DF2EA_var, RegionGetCenter(libSCHO_gv_mMHO_Chaos_TopHoldingPenRegion), true);
        }
        auto63B56D8F_g = UnitGroup("ZergHydralisk", libStEx_gv_pLAYER_12_CHAOS, RegionCircle(RegionGetCenter(libSCHO_gv_mMHO_Chaos_TopHoldingPenRegion), 20.0), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
        auto63B56D8F_u = UnitGroupCount(auto63B56D8F_g, c_unitCountAll);
        for (;; auto63B56D8F_u -= 1) {
            auto63B56D8F_var = UnitGroupUnitFromEnd(auto63B56D8F_g, auto63B56D8F_u);
            if (auto63B56D8F_var == null) { break; }
            libStEx_gf_MoveUnit(auto63B56D8F_var, RegionGetCenter(libSCHO_gv_mMHO_Chaos_TopHoldingPenRegion), true);
        }
        auto45FE1551_g = UnitGroup("ZergUltralisk", libStEx_gv_pLAYER_12_CHAOS, RegionCircle(RegionGetCenter(libSCHO_gv_mMHO_Chaos_TopHoldingPenRegion), 20.0), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
        auto45FE1551_u = UnitGroupCount(auto45FE1551_g, c_unitCountAll);
        for (;; auto45FE1551_u -= 1) {
            auto45FE1551_var = UnitGroupUnitFromEnd(auto45FE1551_g, auto45FE1551_u);
            if (auto45FE1551_var == null) { break; }
            libStEx_gf_MoveUnit(auto45FE1551_var, RegionGetCenter(libSCHO_gv_mMHO_Chaos_TopHoldingPenRegion), true);
        }
        autoDA226475_g = UnitGroup("ZergGuardian", libStEx_gv_pLAYER_12_CHAOS, RegionCircle(RegionGetCenter(libSCHO_gv_mMHO_Chaos_TopHoldingPenRegion), 20.0), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
        autoDA226475_u = UnitGroupCount(autoDA226475_g, c_unitCountAll);
        for (;; autoDA226475_u -= 1) {
            autoDA226475_var = UnitGroupUnitFromEnd(autoDA226475_g, autoDA226475_u);
            if (autoDA226475_var == null) { break; }
            libStEx_gf_MoveUnit(autoDA226475_var, RegionGetCenter(libSCHO_gv_mMHO_Chaos_TopHoldingPenRegion), true);
        }
    }
    else {
        autoADD67D88_g = UnitGroup("ZergZergling", libStEx_gv_pLAYER_11_ORDER, RegionCircle(RegionGetCenter(libSCHO_gv_mMHO_Order_TopHoldingPenRegion), 20.0), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
        autoADD67D88_u = UnitGroupCount(autoADD67D88_g, c_unitCountAll);
        for (;; autoADD67D88_u -= 1) {
            autoADD67D88_var = UnitGroupUnitFromEnd(autoADD67D88_g, autoADD67D88_u);
            if (autoADD67D88_var == null) { break; }
            libStEx_gf_MoveUnit(autoADD67D88_var, RegionGetCenter(libSCHO_gv_mMHO_Order_TopHoldingPenRegion), true);
        }
        auto1B3E2CBB_g = UnitGroup("ZergBaneling", libStEx_gv_pLAYER_11_ORDER, RegionCircle(RegionGetCenter(libSCHO_gv_mMHO_Order_TopHoldingPenRegion), 20.0), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
        auto1B3E2CBB_u = UnitGroupCount(auto1B3E2CBB_g, c_unitCountAll);
        for (;; auto1B3E2CBB_u -= 1) {
            auto1B3E2CBB_var = UnitGroupUnitFromEnd(auto1B3E2CBB_g, auto1B3E2CBB_u);
            if (auto1B3E2CBB_var == null) { break; }
            libStEx_gf_MoveUnit(auto1B3E2CBB_var, RegionGetCenter(libSCHO_gv_mMHO_Order_TopHoldingPenRegion), true);
        }
        autoCCA4D170_g = UnitGroup("ZergHydralisk", libStEx_gv_pLAYER_11_ORDER, RegionCircle(RegionGetCenter(libSCHO_gv_mMHO_Order_TopHoldingPenRegion), 20.0), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
        autoCCA4D170_u = UnitGroupCount(autoCCA4D170_g, c_unitCountAll);
        for (;; autoCCA4D170_u -= 1) {
            autoCCA4D170_var = UnitGroupUnitFromEnd(autoCCA4D170_g, autoCCA4D170_u);
            if (autoCCA4D170_var == null) { break; }
            libStEx_gf_MoveUnit(autoCCA4D170_var, RegionGetCenter(libSCHO_gv_mMHO_Order_TopHoldingPenRegion), true);
        }
        auto1C75291D_g = UnitGroup("ZergUltralisk", libStEx_gv_pLAYER_11_ORDER, RegionCircle(RegionGetCenter(libSCHO_gv_mMHO_Order_TopHoldingPenRegion), 20.0), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
        auto1C75291D_u = UnitGroupCount(auto1C75291D_g, c_unitCountAll);
        for (;; auto1C75291D_u -= 1) {
            auto1C75291D_var = UnitGroupUnitFromEnd(auto1C75291D_g, auto1C75291D_u);
            if (auto1C75291D_var == null) { break; }
            libStEx_gf_MoveUnit(auto1C75291D_var, RegionGetCenter(libSCHO_gv_mMHO_Order_TopHoldingPenRegion), true);
        }
        auto1E5C2F55_g = UnitGroup("ZergGuardian", libStEx_gv_pLAYER_11_ORDER, RegionCircle(RegionGetCenter(libSCHO_gv_mMHO_Order_TopHoldingPenRegion), 20.0), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
        auto1E5C2F55_u = UnitGroupCount(auto1E5C2F55_g, c_unitCountAll);
        for (;; auto1E5C2F55_u -= 1) {
            auto1E5C2F55_var = UnitGroupUnitFromEnd(auto1E5C2F55_g, auto1E5C2F55_u);
            if (auto1E5C2F55_var == null) { break; }
            libStEx_gf_MoveUnit(auto1E5C2F55_var, RegionGetCenter(libSCHO_gv_mMHO_Order_TopHoldingPenRegion), true);
        }
        auto66B9FCA0_g = UnitGroup("ZergZergling", libStEx_gv_pLAYER_12_CHAOS, RegionCircle(RegionGetCenter(libSCHO_gv_mMHO_Chaos_BottomHoldingPenRegion), 20.0), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
        auto66B9FCA0_u = UnitGroupCount(auto66B9FCA0_g, c_unitCountAll);
        for (;; auto66B9FCA0_u -= 1) {
            auto66B9FCA0_var = UnitGroupUnitFromEnd(auto66B9FCA0_g, auto66B9FCA0_u);
            if (auto66B9FCA0_var == null) { break; }
            libStEx_gf_MoveUnit(auto66B9FCA0_var, RegionGetCenter(libSCHO_gv_mMHO_Chaos_BottomHoldingPenRegion), true);
        }
        autoC59DED3F_g = UnitGroup("ZergBaneling", libStEx_gv_pLAYER_12_CHAOS, RegionCircle(RegionGetCenter(libSCHO_gv_mMHO_Chaos_BottomHoldingPenRegion), 20.0), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
        autoC59DED3F_u = UnitGroupCount(autoC59DED3F_g, c_unitCountAll);
        for (;; autoC59DED3F_u -= 1) {
            autoC59DED3F_var = UnitGroupUnitFromEnd(autoC59DED3F_g, autoC59DED3F_u);
            if (autoC59DED3F_var == null) { break; }
            libStEx_gf_MoveUnit(autoC59DED3F_var, RegionGetCenter(libSCHO_gv_mMHO_Chaos_BottomHoldingPenRegion), true);
        }
        auto22465BFF_g = UnitGroup("ZergHydralisk", libStEx_gv_pLAYER_12_CHAOS, RegionCircle(RegionGetCenter(libSCHO_gv_mMHO_Chaos_BottomHoldingPenRegion), 20.0), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
        auto22465BFF_u = UnitGroupCount(auto22465BFF_g, c_unitCountAll);
        for (;; auto22465BFF_u -= 1) {
            auto22465BFF_var = UnitGroupUnitFromEnd(auto22465BFF_g, auto22465BFF_u);
            if (auto22465BFF_var == null) { break; }
            libStEx_gf_MoveUnit(auto22465BFF_var, RegionGetCenter(libSCHO_gv_mMHO_Chaos_BottomHoldingPenRegion), true);
        }
        auto96286027_g = UnitGroup("ZergUltralisk", libStEx_gv_pLAYER_12_CHAOS, RegionCircle(RegionGetCenter(libSCHO_gv_mMHO_Chaos_BottomHoldingPenRegion), 20.0), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
        auto96286027_u = UnitGroupCount(auto96286027_g, c_unitCountAll);
        for (;; auto96286027_u -= 1) {
            auto96286027_var = UnitGroupUnitFromEnd(auto96286027_g, auto96286027_u);
            if (auto96286027_var == null) { break; }
            libStEx_gf_MoveUnit(auto96286027_var, RegionGetCenter(libSCHO_gv_mMHO_Chaos_BottomHoldingPenRegion), true);
        }
        auto9EF49945_g = UnitGroup("ZergGuardian", libStEx_gv_pLAYER_12_CHAOS, RegionCircle(RegionGetCenter(libSCHO_gv_mMHO_Chaos_BottomHoldingPenRegion), 20.0), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
        auto9EF49945_u = UnitGroupCount(auto9EF49945_g, c_unitCountAll);
        for (;; auto9EF49945_u -= 1) {
            auto9EF49945_var = UnitGroupUnitFromEnd(auto9EF49945_g, auto9EF49945_u);
            if (auto9EF49945_var == null) { break; }
            libStEx_gf_MoveUnit(auto9EF49945_var, RegionGetCenter(libSCHO_gv_mMHO_Chaos_BottomHoldingPenRegion), true);
        }
    }
    return true;
}

void libSCHO_gf_MMHOAttackWavePath (unitgroup lp_topGroup, unitgroup lp_botGroup) {
    // Automatic Variable Declarations
    // Implementation
    if ((libSCHO_gv_mMHO_AttackLane == 1)) {
        if ((UnitIsAlive(libGame_gv_townTownData[2].lv_structureUnits[libGame_gv_townTownData[2].lv_townHallIndex]) == true)) {
            libSCHO_gf_MMHOSendAttackWave(lp_topGroup, libSCHO_gv_mMHO_AttackPointsFort[2][1], libGame_gv_teamOrderIndex_C);
        }
        else {
            libSCHO_gf_MMHOSendAttackWave(lp_topGroup, libSCHO_gv_mMHO_AttackPointsKeep[2][1], libGame_gv_teamOrderIndex_C);
        }
        if ((UnitIsAlive(libGame_gv_townTownData[8].lv_structureUnits[libGame_gv_townTownData[8].lv_townHallIndex]) == true)) {
            libSCHO_gf_MMHOSendAttackWave(lp_botGroup, libSCHO_gv_mMHO_AttackPointsFort[3][1], libGame_gv_teamChaosIndex_C);
        }
        else {
            libSCHO_gf_MMHOSendAttackWave(lp_botGroup, libSCHO_gv_mMHO_AttackPointsKeep[3][1], libGame_gv_teamChaosIndex_C);
        }
    }
    else {
        if ((UnitIsAlive(libGame_gv_townTownData[4].lv_structureUnits[libGame_gv_townTownData[4].lv_townHallIndex]) == true)) {
            libSCHO_gf_MMHOSendAttackWave(lp_botGroup, libSCHO_gv_mMHO_AttackPointsFort[4][1], libGame_gv_teamOrderIndex_C);
        }
        else {
            libSCHO_gf_MMHOSendAttackWave(lp_botGroup, libSCHO_gv_mMHO_AttackPointsFort[4][1], libGame_gv_teamOrderIndex_C);
        }
        if ((UnitIsAlive(libGame_gv_townTownData[6].lv_structureUnits[libGame_gv_townTownData[6].lv_townHallIndex]) == true)) {
            libSCHO_gf_MMHOSendAttackWave(lp_topGroup, libSCHO_gv_mMHO_AttackPointsFort[1][1], libGame_gv_teamChaosIndex_C);
        }
        else {
            libSCHO_gf_MMHOSendAttackWave(lp_topGroup, libSCHO_gv_mMHO_AttackPointsKeep[1][1], libGame_gv_teamChaosIndex_C);
        }
    }
}

trigger auto_libSCHO_gf_MMHOSendAttackWave_Trigger = null;
unitgroup auto_libSCHO_gf_MMHOSendAttackWave_lp_waveUnits;
point auto_libSCHO_gf_MMHOSendAttackWave_lp_wP1;
int auto_libSCHO_gf_MMHOSendAttackWave_lp_teamToAttack;

void libSCHO_gf_MMHOSendAttackWave (unitgroup lp_waveUnits, point lp_wP1, int lp_teamToAttack) {
    auto_libSCHO_gf_MMHOSendAttackWave_lp_waveUnits = lp_waveUnits;
    auto_libSCHO_gf_MMHOSendAttackWave_lp_wP1 = lp_wP1;
    auto_libSCHO_gf_MMHOSendAttackWave_lp_teamToAttack = lp_teamToAttack;

    if (auto_libSCHO_gf_MMHOSendAttackWave_Trigger == null) {
        auto_libSCHO_gf_MMHOSendAttackWave_Trigger = TriggerCreate("auto_libSCHO_gf_MMHOSendAttackWave_TriggerFunc");
    }

    TriggerExecute(auto_libSCHO_gf_MMHOSendAttackWave_Trigger, false, false);
}

bool auto_libSCHO_gf_MMHOSendAttackWave_TriggerFunc (bool testConds, bool runActions) {
    unitgroup lp_waveUnits = auto_libSCHO_gf_MMHOSendAttackWave_lp_waveUnits;
    point lp_wP1 = auto_libSCHO_gf_MMHOSendAttackWave_lp_wP1;
    int lp_teamToAttack = auto_libSCHO_gf_MMHOSendAttackWave_lp_teamToAttack;

    // Variable Declarations
    unitgroup lv_waveGroup;
    unit lv_itUnit;

    // Automatic Variable Declarations
    unitgroup auto23860D9C_g;
    int auto23860D9C_u;

    // Variable Initialization
    lv_waveGroup = UnitGroupEmpty();

    // Implementation
    lv_waveGroup = UnitGroupCopy(lp_waveUnits);
    auto23860D9C_g = lv_waveGroup;
    auto23860D9C_u = UnitGroupCount(auto23860D9C_g, c_unitCountAll);
    for (;; auto23860D9C_u -= 1) {
        lv_itUnit = UnitGroupUnitFromEnd(auto23860D9C_g, auto23860D9C_u);
        if (lv_itUnit == null) { break; }
        libGame_gf_CalculateSpawnedMinionGoalPoints(libGame_gf_EnemyTeam(lp_teamToAttack), lp_wP1);
        libAIAI_gf_MinionAIStartMinionAI(-1, lv_itUnit, libGame_gv_spawnedMinionLane, libGame_gv_spawnedMinionFirstWaypointIndex, true, false, true, lp_teamToAttack, true);
        UnitGroupRemove(lv_waveGroup, lv_itUnit);
    }
    return true;
}

void libSCHO_gf_MMHOZergAttackFinishedMonitorWait () {
    // Automatic Variable Declarations
    // Implementation
    while (!(((UnitGroupCount(libSCHO_gv_mMHO_AttackGroups[libGame_gv_teamOrderIndex_C][1], c_unitCountAlive) == 0) && (UnitGroupCount(libSCHO_gv_mMHO_AttackGroups[libGame_gv_teamChaosIndex_C][1], c_unitCountAlive) == 0)))) {
        Wait(1.0, c_timeGame);
    }
    libAIAI_gf_AITeamDelegateActivateDeactivateMapReward(libAIAI_ge_AITeamDelegateActivateDeactivateMapToken_Deactivate);
    SoundPlayForPlayer(SoundLink("Event_BraxisHoldout_EventEnd", -1), c_maxPlayers, PlayerGroupAll(), 100.0, 0.0);
    SoundtrackStopCurrent(libCore_gv_allHeroPlayersPlusObserver, c_soundtrackCategoryMusic, true);
    libSCHO_gf_MMHOUISetMode(libSCHO_ge_MMHOUIModes_Idle);
    libSCHO_gv_mMHO_HiveControlBeaconEventActive = false;
    libSCHO_gv_mMHO_TeamProgress[libGame_gv_teamOrderIndex_C] = 0.0;
    libSCHO_gv_mMHO_TeamProgress[libGame_gv_teamChaosIndex_C] = 0.0;
    libSCHO_gv_mMHO_ZerglingCount[libGame_gv_teamOrderIndex_C] = 0;
    libSCHO_gv_mMHO_BanelingCount[libGame_gv_teamOrderIndex_C] = 0;
    libSCHO_gv_mMHO_ZerglingCount[libGame_gv_teamChaosIndex_C] = 0;
    libSCHO_gv_mMHO_BanelingCount[libGame_gv_teamChaosIndex_C] = 0;
    libSCHO_gf_MMHOResetSpawnProgressVariables(libGame_gv_teamOrderIndex_C);
    libSCHO_gf_MMHOOpenCloseCaptureCages(false, libGame_gv_teamOrderIndex_C);
    libSCHO_gf_MMHOOpenCloseCaptureCages(false, libGame_gv_teamChaosIndex_C);
    libSCHO_gf_MMHOResetSpawnProgressVariables(libGame_gv_teamChaosIndex_C);
    libNtve_gf_SetDialogItemText(libSCHO_gv_mMHOPanel.lv_beaconProgressHPBarLabel[1][1], (FixedToText(libSCHO_gv_mMHO_TeamProgress[libGame_gv_teamOrderIndex_C], 0) + StringExternal("Param/Value/lib_SCHO_4E2E5A66")), PlayerGroupAll());
    libNtve_gf_SetDialogItemText(libSCHO_gv_mMHOPanel.lv_beaconProgressHPBarLabel[2][1], (FixedToText(libSCHO_gv_mMHO_TeamProgress[libGame_gv_teamOrderIndex_C], 0) + StringExternal("Param/Value/lib_SCHO_D4E4D430")), PlayerGroupAll());
    libNtve_gf_SetDialogItemText(libSCHO_gv_mMHOPanel.lv_beaconProgressHPBarLabel[1][2], (FixedToText(libSCHO_gv_mMHO_TeamProgress[libGame_gv_teamChaosIndex_C], 0) + StringExternal("Param/Value/lib_SCHO_0CDA91D8")), PlayerGroupAll());
    libNtve_gf_SetDialogItemText(libSCHO_gv_mMHOPanel.lv_beaconProgressHPBarLabel[2][2], (FixedToText(libSCHO_gv_mMHO_TeamProgress[libGame_gv_teamChaosIndex_C], 0) + StringExternal("Param/Value/lib_SCHO_E9A783F7")), PlayerGroupAll());
    DialogControlSendAnimationEvent(libSCHO_gv_mMHOPanel.lv_beaconProgressFrame[1], PlayerGroupAll(), "TopBarPulseStop");
    DialogControlSendAnimationEvent(libSCHO_gv_mMHOPanel.lv_beaconProgressFrame[2], PlayerGroupAll(), "TopBarPulseStop");
    DialogControlSendAnimationEvent(libSCHO_gv_mMHOPanel.lv_beaconProgressFrame[1], PlayerGroupAll(), "BottomBarPulseStop");
    DialogControlSendAnimationEvent(libSCHO_gv_mMHOPanel.lv_beaconProgressFrame[2], PlayerGroupAll(), "BottomBarPulseStop");
    UnitRemove(libSCHO_gv_mMHO_OrderProgressUnit);
    UnitRemove(libSCHO_gv_mMHO_ChaosProgressUnit);
    libSCHO_gv_mMHO_OrderProgressUnit = null;
    libSCHO_gv_mMHO_ChaosProgressUnit = null;
    libMapM_gf_JungleStopHibernateCamps();
    libSond_gf_SoundtrackPlayMapSoundtrackAsDefaultSoundtrackForAllPlayers();
    libSCHO_gf_MMHOTransmissionAllZergDead();
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_zergHudLeft[1], libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroup, false);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_zergHudLeft[1], libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer], false);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_zergHudLeft[2], libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroup, false);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_zergHudRight[1], libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroup, false);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_zergHudRight[1], libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer], false);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_zergHudRight[2], libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroup, false);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_alliedZergLabel[1], libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroup, false);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_alliedZergLabel[1], libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer], false);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_alliedZergLabel[2], libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroup, false);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_enemyZergLabel[1], libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroup, false);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_enemyZergLabel[1], libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer], false);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_enemyZergLabel[2], libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroup, false);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconProgressLabel[1], libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroup, true);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconProgressLabel[1], libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer], true);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconProgressLabel[2], libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroup, true);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_eggIconImageLeft[1], libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroup, true);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_eggIconImageLeft[1], libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer], true);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_eggIconImageLeft[2], libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroup, true);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_eggIconImageRight[1], libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroup, true);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_eggIconImageRight[1], libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer], true);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_eggIconImageRight[2], libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroup, true);
    TimerStart(libSCHO_gv_mMHO_AttackEventTimer, libSCHO_gv_mMHO_AttackEventDuration_C, false, c_timeGame);
    TriggerEnable(libSCHO_gt_MMHOUpdateZergPath, false);
    if ((libSCHO_gv_mMHO_AttackLaneHPMiniMapController == 1)) {
        UnitBehaviorRemove(libSCHO_gv_mMHO_HiveCages[1].lv_south, "HoldingPenControllerBL", 1);
        UnitBehaviorRemove(libSCHO_gv_mMHO_HiveCages[2].lv_north, "HoldingPenControllerTR", 1);
        UnitBehaviorRemove(libSCHO_gv_mMHO_HiveCages[2].lv_south, "HoldingPenControllerBR", 1);
        UnitBehaviorRemove(libSCHO_gv_mMHO_HiveCages[1].lv_north, "HoldingPenControllerTL", 1);
        UnitBehaviorRemove(libSCHO_gv_mMHO_HiveCages[1].lv_north, "HoldingPenAnimation", 1);
        UnitBehaviorRemove(libSCHO_gv_mMHO_HiveCages[2].lv_south, "HoldingPenAnimation", 1);
    }
    else {
        UnitBehaviorRemove(libSCHO_gv_mMHO_HiveCages[1].lv_south, "HoldingPenControllerBL", 1);
        UnitBehaviorRemove(libSCHO_gv_mMHO_HiveCages[2].lv_north, "HoldingPenControllerTR", 1);
        UnitBehaviorRemove(libSCHO_gv_mMHO_HiveCages[2].lv_south, "HoldingPenControllerBR", 1);
        UnitBehaviorRemove(libSCHO_gv_mMHO_HiveCages[1].lv_north, "HoldingPenControllerTL", 1);
        UnitBehaviorRemove(libSCHO_gv_mMHO_HiveCages[1].lv_south, "HoldingPenAnimation", 1);
        UnitBehaviorRemove(libSCHO_gv_mMHO_HiveCages[2].lv_north, "HoldingPenAnimation", 1);
    }
    libSCHO_gv_mMHO_AttackLaneHPMiniMapController = (3 - libSCHO_gv_mMHO_AttackLane);
    libSCHO_gf_MMHOControlSlabAnimationsEventStartStop(libSCHO_ge_MMHO_BeaconSignals_Stop);
}

void libSCHO_gf_MMHOSetupZergAttackWave () {
    // Variable Declarations
    int lv_itTeam;

    // Automatic Variable Declarations
    int auto0FA3C7F3_val;

    // Variable Initialization

    // Implementation
    auto0FA3C7F3_val = libSCHO_gv_mMHO_WaveTracker;
    if (auto0FA3C7F3_val == 1) {
        libSCHO_gf_MMHOSpawnBeaconWave();
        libSCHO_gf_MMHODetermineAttackWavePath(libSCHO_gv_mMHO_WaveTracker);
        UIDisplayMessage(PlayerGroupAll(), c_messageAreaSubtitle, StringExternal("Param/Value/lib_SCHO_C2B1EB0F"));
        Wait(5.0625, c_timeGame);
        libSCHO_gf_MMHOZergAttackFinishedMonitorWait();
        libSCHO_gv_mMHO_WaveTracker = 1;
    }
    else if (auto0FA3C7F3_val == 2) {
        libSCHO_gf_MMHOSpawnBeaconWave();
        libSCHO_gf_MMHODetermineAttackWavePath(libSCHO_gv_mMHO_WaveTracker);
    }
    else {
    }
}

void libSCHO_gf_MMHOSpawnBeaconWave () {
    // Variable Declarations
    int lv_groupIndex;
    int lv_random;
    int lv_itUserData;
    int lv_itSpawnUnit;
    int lv_itSpawnRegion;
    region lv_topSpawnRegion;
    region lv_bottomSpawnRegion;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_topSpawnRegion = libSCHO_gv_mMHO_Chaos_TopSpawnRegion;

    // Implementation
    if ((libSCHO_gv_mMHO_AttackLane == 1)) {
        lv_topSpawnRegion = libSCHO_gv_mMHO_Chaos_TopSpawnRegion;
        lv_bottomSpawnRegion = libSCHO_gv_mMHO_Order_BottomSpawnRegion;
    }
    else {
        lv_topSpawnRegion = libSCHO_gv_mMHO_Order_TopSpawnRegion;
        lv_bottomSpawnRegion = libSCHO_gv_mMHO_Chaos_BottomSpawnRegion;
    }
    libSCHO_gf_MMHOSpawnBeaconUnits(libSCHO_gv_mMHO_AttackLane, lv_topSpawnRegion);
    libSCHO_gf_MMHOSpawnBeaconUnits((3 - libSCHO_gv_mMHO_AttackLane), lv_bottomSpawnRegion);
    Wait(5.0, c_timeGame);
}

trigger auto_libSCHO_gf_MMHOSpawnBeaconUnits_Trigger = null;
int auto_libSCHO_gf_MMHOSpawnBeaconUnits_lp_attackLane;
region auto_libSCHO_gf_MMHOSpawnBeaconUnits_lp_spawnRegion;

void libSCHO_gf_MMHOSpawnBeaconUnits (int lp_attackLane, region lp_spawnRegion) {
    auto_libSCHO_gf_MMHOSpawnBeaconUnits_lp_attackLane = lp_attackLane;
    auto_libSCHO_gf_MMHOSpawnBeaconUnits_lp_spawnRegion = lp_spawnRegion;

    if (auto_libSCHO_gf_MMHOSpawnBeaconUnits_Trigger == null) {
        auto_libSCHO_gf_MMHOSpawnBeaconUnits_Trigger = TriggerCreate("auto_libSCHO_gf_MMHOSpawnBeaconUnits_TriggerFunc");
    }

    TriggerExecute(auto_libSCHO_gf_MMHOSpawnBeaconUnits_Trigger, false, false);
}

bool auto_libSCHO_gf_MMHOSpawnBeaconUnits_TriggerFunc (bool testConds, bool runActions) {
    int lp_attackLane = auto_libSCHO_gf_MMHOSpawnBeaconUnits_lp_attackLane;
    region lp_spawnRegion = auto_libSCHO_gf_MMHOSpawnBeaconUnits_lp_spawnRegion;

    // Variable Declarations
    int lv_owner;
    int lv_itUserData;
    int lv_itSpawnUnit;
    string lv_tier;
    string lv_wave;
    int lv_itZergling;
    string lv_count;
    int lv_team;

    // Automatic Variable Declarations
    const int autoAD53C12D_ae = 3;
    const int autoAD53C12D_ai = 1;
    int auto2149D197_ae;
    const int auto2149D197_ai = 1;
    int autoE1768950_val;

    // Variable Initialization

    // Implementation
    if (((lp_spawnRegion == libSCHO_gv_mMHO_Chaos_TopSpawnRegion) || (lp_spawnRegion == libSCHO_gv_mMHO_Chaos_BottomSpawnRegion))) {
        lv_owner = libCore_gv_cOMPUTER_TeamChaos;
        lv_team = libGame_gv_teamChaosIndex_C;
        lv_tier = libSCHO_gv_mMHO_TeamZergTier[libGame_gv_teamChaosIndex_C];
    }
    else {
        lv_owner = libCore_gv_cOMPUTER_TeamOrder;
        lv_team = libGame_gv_teamOrderIndex_C;
        lv_tier = libSCHO_gv_mMHO_TeamZergTier[libGame_gv_teamOrderIndex_C];
    }
    if ((libSCHO_gv_mMHO_WaveTracker == 1)) {
        lv_wave = "Wave 1";
        lv_count = "Count 1";
    }
    else {
        lv_wave = "Wave 2";
        lv_count = "Count 2";
    }
    Wait(0.0625, c_timeGame);
    libSCHO_gf_MMHOSpawnZerglingsBanelings(lp_attackLane, lv_team, lp_spawnRegion);
    lv_itUserData = 1;
    for ( ; ( (autoAD53C12D_ai >= 0 && lv_itUserData <= autoAD53C12D_ae) || (autoAD53C12D_ai < 0 && lv_itUserData >= autoAD53C12D_ae) ) ; lv_itUserData += autoAD53C12D_ai ) {
        auto2149D197_ae = UserDataGetInt("BeaconWaves", lv_tier, lv_count, lv_itUserData);
        lv_itSpawnUnit = 1;
        for ( ; ( (auto2149D197_ai >= 0 && lv_itSpawnUnit <= auto2149D197_ae) || (auto2149D197_ai < 0 && lv_itSpawnUnit >= auto2149D197_ae) ) ; lv_itSpawnUnit += auto2149D197_ai ) {
            libNtve_gf_CreateUnitsWithDefaultFacing(1, UserDataGetUnit("BeaconWaves", lv_tier, lv_wave, lv_itUserData), 0, lv_owner, RegionRandomPoint(lp_spawnRegion), null);
            UnitGroupAdd(libSCHO_gv_mMHO_AttackGroups[lp_attackLane][libSCHO_gv_mMHO_WaveTracker], UnitLastCreated());
            UnitXPAddXP(UnitLastCreated(), null, libSCHO_gv_mMHO_ScalingLevel);
            Wait(RandomFixed(0.0625, 0.125), c_timeGame);
            autoE1768950_val = libSCHO_gv_mMHO_WaveTracker;
            if (autoE1768950_val == 1) {
                UnitBehaviorAdd(UnitLastCreated(), "Group1", UnitLastCreated(), 1);
            }
            else if (autoE1768950_val == 2) {
                UnitBehaviorAdd(UnitLastCreated(), "Group2", UnitLastCreated(), 1);
            }
            else if (autoE1768950_val == 3) {
                UnitBehaviorAdd(UnitLastCreated(), "Group3", UnitLastCreated(), 1);
            }
            else {
            }
        }
    }
    return true;
}

void libSCHO_gf_MMHOGrantFreeZergUnits (int lp_team) {
    // Variable Declarations
    region lv_spawnRegion;
    point lv_moveTargetLocation;
    int lv_owner;
    unit lv_itUnit;
    unitgroup lv_freeZergUnitsGroup;

    // Automatic Variable Declarations
    unitgroup autoD843BB99_g;
    int autoD843BB99_u;

    // Variable Initialization
    lv_freeZergUnitsGroup = UnitGroupEmpty();

    // Implementation
    if ((lp_team == libGame_gv_teamOrderIndex_C)) {
        lv_owner = libCore_gv_cOMPUTER_TeamOrder;
        if ((libSCHO_gv_mMHO_AttackLane == 1)) {
            lv_spawnRegion = libSCHO_gv_mMHO_Order_BottomSpawnRegion;
            lv_moveTargetLocation = RegionRandomPoint(libSCHO_gv_mMHOSpawnCageRegions[2].lv_frontSpawnRegion);
        }
        else {
            lv_spawnRegion = libSCHO_gv_mMHO_Order_TopSpawnRegion;
            lv_moveTargetLocation = RegionRandomPoint(libSCHO_gv_mMHOSpawnCageRegions[0].lv_frontSpawnRegion);
        }
    }
    else {
        lv_owner = libCore_gv_cOMPUTER_TeamChaos;
        if ((libSCHO_gv_mMHO_AttackLane == 1)) {
            lv_spawnRegion = libSCHO_gv_mMHO_Chaos_TopSpawnRegion;
            lv_moveTargetLocation = RegionRandomPoint(libSCHO_gv_mMHOSpawnCageRegions[1].lv_frontSpawnRegion);
        }
        else {
            lv_spawnRegion = libSCHO_gv_mMHO_Chaos_BottomSpawnRegion;
            lv_moveTargetLocation = RegionRandomPoint(libSCHO_gv_mMHOSpawnCageRegions[3].lv_frontSpawnRegion);
        }
    }
    libNtve_gf_CreateUnitsAtPoint2(libSCHO_gv_mMHO_FreeZerglingCount_C, "ZergZergling", c_unitCreateIgnorePlacement, lv_owner, RegionRandomPoint(lv_spawnRegion), libGame_gv_teams[lp_team].lv_core);
    UnitGroupAddUnitGroup(lv_freeZergUnitsGroup, UnitLastCreatedGroup());

    libNtve_gf_CreateUnitsAtPoint2(libSCHO_gv_mMHO_FreeBanelingCount_C, "ZergBaneling", c_unitCreateIgnorePlacement, lv_owner, RegionRandomPoint(lv_spawnRegion), libGame_gv_teams[lp_team].lv_core);
    UnitGroupAddUnitGroup(lv_freeZergUnitsGroup, UnitLastCreatedGroup());

    libNtve_gf_CreateUnitsAtPoint2(libSCHO_gv_mMHO_FreeHydraliskCount_C, "ZergHydralisk", c_unitCreateIgnorePlacement, lv_owner, RegionRandomPoint(lv_spawnRegion), libGame_gv_teams[lp_team].lv_core);
    UnitGroupAddUnitGroup(lv_freeZergUnitsGroup, UnitLastCreatedGroup());

    libNtve_gf_CreateUnitsAtPoint2(libSCHO_gv_mMHO_FreeUltraliskCount_C, "ZergUltralisk", c_unitCreateIgnorePlacement, lv_owner, RegionRandomPoint(lv_spawnRegion), libGame_gv_teams[lp_team].lv_core);
    UnitGroupAddUnitGroup(lv_freeZergUnitsGroup, UnitLastCreatedGroup());

    libNtve_gf_CreateUnitsAtPoint2(libSCHO_gv_mMHO_FreeGuardianCount_C, "ZergGuardian", c_unitCreateIgnorePlacement, lv_owner, RegionRandomPoint(lv_spawnRegion), libGame_gv_teams[lp_team].lv_core);
    UnitGroupAdd(lv_freeZergUnitsGroup, UnitLastCreated());

    autoD843BB99_g = lv_freeZergUnitsGroup;
    autoD843BB99_u = UnitGroupCount(autoD843BB99_g, c_unitCountAll);
    for (;; autoD843BB99_u -= 1) {
        lv_itUnit = UnitGroupUnitFromEnd(autoD843BB99_g, autoD843BB99_u);
        if (lv_itUnit == null) { break; }
        UnitGroupAdd(libSCHO_gv_mMHO_AttackGroups[lp_team][libSCHO_gv_mMHO_WaveTracker], lv_itUnit);
        UnitBehaviorAdd(lv_itUnit, "ZergStasisBehavior", lv_itUnit, 1);
        libAIAI_gf_MinionAIUnhookUnitFromMinionAI(lv_itUnit);
        UnitIssueOrder(lv_itUnit, OrderTargetingPoint(AbilityCommand("move", 0), PointWithOffsetPolar(lv_moveTargetLocation, RandomInt(0, 3), RandomFixed(0.0, 360.0))), c_orderQueueReplace);
    }
}

void libSCHO_gf_MMHOPeriodicallySpawnZergUnits (int lp_team) {
    // Variable Declarations
    region lv_spawnRegion;
    region lv_topSpawnRegion;
    region lv_bottomSpawnRegion;
    int lv_spawnQuadrant;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_topSpawnRegion = libSCHO_gv_mMHO_Chaos_TopSpawnRegion;

    // Implementation
    if ((lp_team == libGame_gv_teamOrderIndex_C)) {
        if ((libSCHO_gv_mMHO_AttackLane == 1)) {
            lv_spawnRegion = libSCHO_gv_mMHO_Order_BottomSpawnRegion;
        }
        else {
            lv_spawnRegion = libSCHO_gv_mMHO_Order_TopSpawnRegion;
        }
    }
    else {
        if ((libSCHO_gv_mMHO_AttackLane == 1)) {
            lv_spawnRegion = libSCHO_gv_mMHO_Chaos_TopSpawnRegion;
        }
        else {
            lv_spawnRegion = libSCHO_gv_mMHO_Chaos_BottomSpawnRegion;
        }
    }
    libSCHO_gf_MMHOModifySpawnProgressVariables(lp_team);
    libSCHO_gf_MMHODetermineSpawnCompositionBasedOnProgress(lp_team, lv_spawnRegion);
}

void libSCHO_gf_MMHOModifySpawnProgressVariables (int lp_team) {
    // Automatic Variable Declarations
    // Implementation
    if ((libSCHO_gv_mMHO_TeamProgress[lp_team] <= libSCHO_gv_mMHO_ZerglingBanelingConversionPoint_C)) {
        libSCHO_gv_mMHO_SpawnProgressTracker[lp_team].lv_zerglingCount += libSCHO_gv_mMHO_ControlBeaconProgressIncrement_C;
    }
    else {
        libSCHO_gv_mMHO_SpawnProgressTracker[lp_team].lv_banelingCount += libSCHO_gv_mMHO_ControlBeaconProgressIncrement_C;
    }
    libSCHO_gv_mMHO_SpawnProgressTracker[lp_team].lv_hydraliskCount += libSCHO_gv_mMHO_ControlBeaconProgressIncrement_C;
    libSCHO_gv_mMHO_SpawnProgressTracker[lp_team].lv_guardianCount += libSCHO_gv_mMHO_ControlBeaconProgressIncrement_C;
    libSCHO_gv_mMHO_SpawnProgressTracker[lp_team].lv_ultraliskCount += libSCHO_gv_mMHO_ControlBeaconProgressIncrement_C;
}

void libSCHO_gf_MMHODetermineSpawnCompositionBasedOnProgress (int lp_team, region lp_spawnRegion) {
    // Variable Declarations
    int lv_zerglingSpawnCount;
    int lv_banelingSpawnCount;
    int lv_hydraliskSpawnCount;
    int lv_guardianSpawnCount;
    int lv_ultraliskSpawnCount;
    int lv_owner;
    point lv_moveTargetLocation;
    region lv_spawnRegion;

    // Automatic Variable Declarations
    int auto97983EC8_ae;
    int auto97983EC8_var;
    int auto5E17FE95_ae;
    int auto5E17FE95_var;
    int auto9A188936_ae;
    int auto9A188936_var;
    int auto34093CCA_ae;
    int auto34093CCA_var;
    int autoE6DF77C6_ae;
    int autoE6DF77C6_var;

    // Variable Initialization

    // Implementation
    if (((lp_spawnRegion == libSCHO_gv_mMHO_Chaos_TopSpawnRegion) || (lp_spawnRegion == libSCHO_gv_mMHO_Chaos_BottomSpawnRegion))) {
        lv_owner = libCore_gv_cOMPUTER_TeamChaos;
        if ((lp_spawnRegion == libSCHO_gv_mMHO_Chaos_TopSpawnRegion)) {
            if ((libSCHO_gv_mMHO_TeamProgress[lp_team] < 33.0)) {
                lv_moveTargetLocation = RegionRandomPoint(libSCHO_gv_mMHOSpawnCageRegions[1].lv_frontSpawnRegion);
            }
            else {
                if ((libSCHO_gv_mMHO_TeamProgress[lp_team] < 66.0)) {
                    lv_moveTargetLocation = RegionRandomPoint(libSCHO_gv_mMHOSpawnCageRegions[1].lv_middleSpawnRegion);
                }
                else {
                    if ((libSCHO_gv_mMHO_TeamProgress[lp_team] <= 100.0)) {
                        lv_moveTargetLocation = RegionRandomPoint(libSCHO_gv_mMHOSpawnCageRegions[1].lv_backSpawnRegion);
                    }

                }
            }
        }
        else {
            if ((libSCHO_gv_mMHO_TeamProgress[lp_team] < 33.0)) {
                lv_moveTargetLocation = RegionRandomPoint(libSCHO_gv_mMHOSpawnCageRegions[3].lv_frontSpawnRegion);
            }
            else {
                if ((libSCHO_gv_mMHO_TeamProgress[lp_team] < 66.0)) {
                    lv_moveTargetLocation = RegionRandomPoint(libSCHO_gv_mMHOSpawnCageRegions[3].lv_middleSpawnRegion);
                }
                else {
                    if ((libSCHO_gv_mMHO_TeamProgress[lp_team] <= 100.0)) {
                        lv_moveTargetLocation = RegionRandomPoint(libSCHO_gv_mMHOSpawnCageRegions[3].lv_backSpawnRegion);
                    }

                }
            }
        }
    }
    else {
        lv_owner = libCore_gv_cOMPUTER_TeamOrder;
        if ((lp_spawnRegion == libSCHO_gv_mMHO_Order_TopSpawnRegion)) {
            if ((libSCHO_gv_mMHO_TeamProgress[lp_team] < 33.0)) {
                lv_moveTargetLocation = RegionRandomPoint(libSCHO_gv_mMHOSpawnCageRegions[0].lv_frontSpawnRegion);
            }
            else {
                if ((libSCHO_gv_mMHO_TeamProgress[lp_team] < 66.0)) {
                    lv_moveTargetLocation = RegionRandomPoint(libSCHO_gv_mMHOSpawnCageRegions[0].lv_middleSpawnRegion);
                }
                else {
                    if ((libSCHO_gv_mMHO_TeamProgress[lp_team] <= 100.0)) {
                        lv_moveTargetLocation = RegionRandomPoint(libSCHO_gv_mMHOSpawnCageRegions[0].lv_backSpawnRegion);
                    }

                }
            }
        }
        else {
            if ((libSCHO_gv_mMHO_TeamProgress[lp_team] < 33.0)) {
                lv_moveTargetLocation = RegionRandomPoint(libSCHO_gv_mMHOSpawnCageRegions[2].lv_frontSpawnRegion);
            }
            else {
                if ((libSCHO_gv_mMHO_TeamProgress[lp_team] < 66.0)) {
                    lv_moveTargetLocation = RegionRandomPoint(libSCHO_gv_mMHOSpawnCageRegions[2].lv_middleSpawnRegion);
                }
                else {
                    if ((libSCHO_gv_mMHO_TeamProgress[lp_team] <= 100.0)) {
                        lv_moveTargetLocation = RegionRandomPoint(libSCHO_gv_mMHOSpawnCageRegions[2].lv_backSpawnRegion);
                    }

                }
            }
        }
    }
    while ((libSCHO_gv_mMHO_SpawnProgressTracker[lp_team].lv_zerglingCount >= libSCHO_gv_mMHO_ZerglingBanelingSubtractor_C)) {
        libSCHO_gv_mMHO_SpawnProgressTracker[lp_team].lv_zerglingCount -= libSCHO_gv_mMHO_ZerglingBanelingSubtractor_C;
        lv_zerglingSpawnCount += 1;
    }
    while ((libSCHO_gv_mMHO_SpawnProgressTracker[lp_team].lv_banelingCount >= libSCHO_gv_mMHO_ZerglingBanelingSubtractor_C)) {
        libSCHO_gv_mMHO_SpawnProgressTracker[lp_team].lv_banelingCount -= libSCHO_gv_mMHO_ZerglingBanelingSubtractor_C;
        lv_banelingSpawnCount += 1;
    }
    while ((libSCHO_gv_mMHO_SpawnProgressTracker[lp_team].lv_hydraliskCount >= libSCHO_gv_mMHO_HydraliskSubtractor_C)) {
        libSCHO_gv_mMHO_SpawnProgressTracker[lp_team].lv_hydraliskCount -= libSCHO_gv_mMHO_HydraliskSubtractor_C;
        lv_hydraliskSpawnCount += 1;
    }
    while ((libSCHO_gv_mMHO_SpawnProgressTracker[lp_team].lv_guardianCount >= libSCHO_gv_mMHO_GuardianSubtractor_C)) {
        libSCHO_gv_mMHO_SpawnProgressTracker[lp_team].lv_guardianCount -= libSCHO_gv_mMHO_GuardianSubtractor_C;
        lv_guardianSpawnCount += 1;
    }
    while ((libSCHO_gv_mMHO_SpawnProgressTracker[lp_team].lv_ultraliskCount >= libSCHO_gv_mMHO_UltraliskSubtractor_C)) {
        libSCHO_gv_mMHO_SpawnProgressTracker[lp_team].lv_ultraliskCount -= libSCHO_gv_mMHO_UltraliskSubtractor_C;
        lv_ultraliskSpawnCount += 1;
    }
    auto97983EC8_ae = lv_zerglingSpawnCount;
    auto97983EC8_var = 1;
    for ( ; auto97983EC8_var <= auto97983EC8_ae; auto97983EC8_var += 1 ) {
        libNtve_gf_CreateUnitsWithDefaultFacing(1, "ZergZergling", c_unitCreateIgnorePlacement, lv_owner, RegionRandomPoint(lp_spawnRegion), null);
        UnitGroupAdd(libSCHO_gv_mMHO_AttackGroups[lp_team][libSCHO_gv_mMHO_WaveTracker], UnitLastCreated());
        UnitBehaviorAdd(UnitLastCreated(), "ZergStasisBehavior", UnitLastCreated(), 1);
        libAIAI_gf_MinionAIUnhookUnitFromMinionAI(UnitLastCreated());
        UnitIssueOrder(UnitLastCreated(), OrderTargetingPoint(AbilityCommand("move", 0), lv_moveTargetLocation), c_orderQueueReplace);
    }
    auto5E17FE95_ae = lv_banelingSpawnCount;
    auto5E17FE95_var = 1;
    for ( ; auto5E17FE95_var <= auto5E17FE95_ae; auto5E17FE95_var += 1 ) {
        libNtve_gf_CreateUnitsWithDefaultFacing(1, "ZergBaneling", c_unitCreateIgnorePlacement, lv_owner, RegionRandomPoint(lp_spawnRegion), null);
        UnitGroupAdd(libSCHO_gv_mMHO_AttackGroups[lp_team][libSCHO_gv_mMHO_WaveTracker], UnitLastCreated());
        UnitBehaviorAdd(UnitLastCreated(), "ZergStasisBehavior", UnitLastCreated(), 1);
        libAIAI_gf_MinionAIUnhookUnitFromMinionAI(UnitLastCreated());
        UnitIssueOrder(UnitLastCreated(), OrderTargetingPoint(AbilityCommand("move", 0), lv_moveTargetLocation), c_orderQueueReplace);
    }
    auto9A188936_ae = lv_hydraliskSpawnCount;
    auto9A188936_var = 1;
    for ( ; auto9A188936_var <= auto9A188936_ae; auto9A188936_var += 1 ) {
        libNtve_gf_CreateUnitsWithDefaultFacing(1, "ZergHydralisk", c_unitCreateIgnorePlacement, lv_owner, RegionRandomPoint(lp_spawnRegion), null);
        UnitGroupAdd(libSCHO_gv_mMHO_AttackGroups[lp_team][libSCHO_gv_mMHO_WaveTracker], UnitLastCreated());
        UnitBehaviorAdd(UnitLastCreated(), "ZergStasisBehavior", UnitLastCreated(), 1);
        libAIAI_gf_MinionAIUnhookUnitFromMinionAI(UnitLastCreated());
        UnitIssueOrder(UnitLastCreated(), OrderTargetingPoint(AbilityCommand("move", 0), lv_moveTargetLocation), c_orderQueueReplace);
    }
    auto34093CCA_ae = lv_guardianSpawnCount;
    auto34093CCA_var = 1;
    for ( ; auto34093CCA_var <= auto34093CCA_ae; auto34093CCA_var += 1 ) {
        libNtve_gf_CreateUnitsWithDefaultFacing(1, "ZergGuardian", c_unitCreateIgnorePlacement, lv_owner, RegionRandomPoint(lp_spawnRegion), null);
        UnitGroupAdd(libSCHO_gv_mMHO_AttackGroups[lp_team][libSCHO_gv_mMHO_WaveTracker], UnitLastCreated());
        UnitBehaviorAdd(UnitLastCreated(), "ZergStasisBehavior", UnitLastCreated(), 1);
        libAIAI_gf_MinionAIUnhookUnitFromMinionAI(UnitLastCreated());
        UnitIssueOrder(UnitLastCreated(), OrderTargetingPoint(AbilityCommand("move", 0), lv_moveTargetLocation), c_orderQueueReplace);
    }
    autoE6DF77C6_ae = lv_ultraliskSpawnCount;
    autoE6DF77C6_var = 1;
    for ( ; autoE6DF77C6_var <= autoE6DF77C6_ae; autoE6DF77C6_var += 1 ) {
        libSCHO_gf_MMHOActivateUltraliskForTeam(lv_moveTargetLocation, lp_team);
    }
}

void libSCHO_gf_MMHOResetSpawnProgressVariables (int lp_team) {
    // Automatic Variable Declarations
    // Implementation
    libSCHO_gv_mMHO_SpawnProgressTracker[lp_team].lv_zerglingCount = 0.0;
    libSCHO_gv_mMHO_SpawnProgressTracker[lp_team].lv_banelingCount = 0.0;
    libSCHO_gv_mMHO_SpawnProgressTracker[lp_team].lv_hydraliskCount = 0.0;
    libSCHO_gv_mMHO_SpawnProgressTracker[lp_team].lv_guardianCount = 0.0;
    libSCHO_gv_mMHO_SpawnProgressTracker[lp_team].lv_ultraliskCount = 0.0;
}

void libSCHO_gf_MMHOSpawnUltralisksForTeam (int lp_team) {
    // Variable Declarations
    point lv_spawnLocation1;
    point lv_spawnLocation2;
    int lv_owner;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    lv_owner = libGame_gf_ComputerPlayerInTeam(lp_team);
    if ((lp_team == libGame_gv_teamOrderIndex_C)) {
        if ((libSCHO_gv_mMHO_AttackLane == 1)) {
            lv_spawnLocation1 = libSCHO_gv_mMHO_Order_BottomUltraliskPoints[1];
            lv_spawnLocation2 = libSCHO_gv_mMHO_Order_BottomUltraliskPoints[2];
        }
        else {
            lv_spawnLocation1 = libSCHO_gv_mMHO_Order_TopUltraliskPoints[1];
            lv_spawnLocation2 = libSCHO_gv_mMHO_Order_TopUltraliskPoints[2];
        }
    }
    else {
        if ((libSCHO_gv_mMHO_AttackLane == 1)) {
            lv_spawnLocation1 = libSCHO_gv_mMHO_Chaos_TopUltraliskPoints[1];
            lv_spawnLocation2 = libSCHO_gv_mMHO_Chaos_TopUltraliskPoints[2];
        }
        else {
            lv_spawnLocation1 = libSCHO_gv_mMHO_Chaos_BottomUltraliskPoints[1];
            lv_spawnLocation2 = libSCHO_gv_mMHO_Chaos_BottomUltraliskPoints[2];
        }
    }
    libNtve_gf_CreateUnitsAtPoint2(1, "ZergUltralisk", c_unitCreateIgnorePlacement, lv_owner, lv_spawnLocation1, null);
    UnitBehaviorAdd(UnitLastCreated(), "ZergStasisBehavior", UnitLastCreated(), 1);
    libAIAI_gf_MinionAIUnhookUnitFromMinionAI(UnitLastCreated());
    if ((lp_team == libGame_gv_teamOrderIndex_C)) {
        UnitGroupAdd(libSCHO_gv_mMHO_OrderUltralisks, UnitLastCreated());
    }
    else {
        UnitGroupAdd(libSCHO_gv_mMHO_ChaosUltralisks, UnitLastCreated());
    }
    libNtve_gf_CreateUnitsAtPoint2(1, "ZergUltralisk", c_unitCreateIgnorePlacement, lv_owner, lv_spawnLocation2, null);
    UnitBehaviorAdd(UnitLastCreated(), "ZergStasisBehavior", UnitLastCreated(), 1);
    libAIAI_gf_MinionAIUnhookUnitFromMinionAI(UnitLastCreated());
    if ((lp_team == libGame_gv_teamOrderIndex_C)) {
        UnitGroupAdd(libSCHO_gv_mMHO_OrderUltralisks, UnitLastCreated());
    }
    else {
        UnitGroupAdd(libSCHO_gv_mMHO_ChaosUltralisks, UnitLastCreated());
    }
}

void libSCHO_gf_MMHOActivateUltraliskForTeam (point lp_targetLocation, int lp_team) {
    // Variable Declarations
    unit lv_ultraliskToActivate;
    unit lv_itUnit;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    libSCHO_gf_MMHOOpenLeftRightUltraliskCages(lp_team);
    if ((lp_team == libGame_gv_teamOrderIndex_C)) {
        lv_ultraliskToActivate = UnitGroupUnit(libSCHO_gv_mMHO_OrderUltralisks, 1);
        UnitGroupRemove(libSCHO_gv_mMHO_OrderUltralisks, lv_ultraliskToActivate);
    }
    else {
        lv_ultraliskToActivate = UnitGroupUnit(libSCHO_gv_mMHO_ChaosUltralisks, 1);
        UnitGroupRemove(libSCHO_gv_mMHO_ChaosUltralisks, lv_ultraliskToActivate);
    }
    libNtve_gf_SendActorMessageToUnit(lv_ultraliskToActivate, "StatusSet Released 1");
    UnitGroupAdd(libSCHO_gv_mMHO_AttackGroups[lp_team][libSCHO_gv_mMHO_WaveTracker], lv_ultraliskToActivate);
    UnitIssueOrder(lv_ultraliskToActivate, OrderTargetingPoint(AbilityCommand("move", 0), lp_targetLocation), c_orderQueueReplace);
}

void libSCHO_gf_MMHOCleanUpRemainingUltralisks () {
    // Variable Declarations
    unit lv_itUnit;

    // Automatic Variable Declarations
    unitgroup auto72CF5C42_g;
    int auto72CF5C42_u;
    unitgroup auto1A40C015_g;
    int auto1A40C015_u;

    // Variable Initialization

    // Implementation
    auto72CF5C42_g = libSCHO_gv_mMHO_ChaosUltralisks;
    auto72CF5C42_u = UnitGroupCount(auto72CF5C42_g, c_unitCountAll);
    for (;; auto72CF5C42_u -= 1) {
        lv_itUnit = UnitGroupUnitFromEnd(auto72CF5C42_g, auto72CF5C42_u);
        if (lv_itUnit == null) { break; }
        UnitKill(lv_itUnit);
    }
    auto1A40C015_g = libSCHO_gv_mMHO_OrderUltralisks;
    auto1A40C015_u = UnitGroupCount(auto1A40C015_g, c_unitCountAll);
    for (;; auto1A40C015_u -= 1) {
        lv_itUnit = UnitGroupUnitFromEnd(auto1A40C015_g, auto1A40C015_u);
        if (lv_itUnit == null) { break; }
        UnitKill(lv_itUnit);
    }
    UnitGroupClear(libSCHO_gv_mMHO_ChaosUltralisks);
    UnitGroupClear(libSCHO_gv_mMHO_OrderUltralisks);
}

void libSCHO_gf_MMHORemoveStasisBehaviorFromZerg () {
    // Variable Declarations
    unit lv_itUnit;

    // Automatic Variable Declarations
    unitgroup auto04A65BF4_g;
    int auto04A65BF4_u;
    unitgroup auto62836594_g;
    int auto62836594_u;

    // Variable Initialization

    // Implementation
    auto04A65BF4_g = libSCHO_gv_mMHO_AttackGroups[libGame_gv_teamOrderIndex_C][libSCHO_gv_mMHO_WaveTracker];
    auto04A65BF4_u = UnitGroupCount(auto04A65BF4_g, c_unitCountAll);
    for (;; auto04A65BF4_u -= 1) {
        lv_itUnit = UnitGroupUnitFromEnd(auto04A65BF4_g, auto04A65BF4_u);
        if (lv_itUnit == null) { break; }
        UnitBehaviorRemove(lv_itUnit, "ZergStasisBehavior", 1);
        UnitXPAddXP(lv_itUnit, null, libSCHO_gv_mMHO_ScalingLevel);
    }
    auto62836594_g = libSCHO_gv_mMHO_AttackGroups[libGame_gv_teamChaosIndex_C][libSCHO_gv_mMHO_WaveTracker];
    auto62836594_u = UnitGroupCount(auto62836594_g, c_unitCountAll);
    for (;; auto62836594_u -= 1) {
        lv_itUnit = UnitGroupUnitFromEnd(auto62836594_g, auto62836594_u);
        if (lv_itUnit == null) { break; }
        UnitBehaviorRemove(lv_itUnit, "ZergStasisBehavior", 1);
        UnitXPAddXP(lv_itUnit, null, libSCHO_gv_mMHO_ScalingLevel);
    }
}

void libSCHO_gf_MMHODetermineFreeZerglingBanelingCount () {
    // Variable Declarations
    int lv_team;

    // Automatic Variable Declarations
    const int auto409D017F_ae = 2;
    const int auto409D017F_ai = 1;

    // Variable Initialization

    // Implementation
    lv_team = 1;
    for ( ; ( (auto409D017F_ai >= 0 && lv_team <= auto409D017F_ae) || (auto409D017F_ai < 0 && lv_team >= auto409D017F_ae) ) ; lv_team += auto409D017F_ai ) {
        while ((libSCHO_gv_mMHO_TeamProgress[lv_team] > 0.0)) {
            if ((libSCHO_gv_mMHO_TeamProgress[lv_team] >= 51.0)) {
                libSCHO_gv_mMHO_TeamProgress[lv_team] -= libSCHO_gv_mMHO_ZerglingBanelingSubtractor_C;
                libSCHO_gv_mMHO_BanelingCount[lv_team] += 1;
            }
            else {
                libSCHO_gv_mMHO_TeamProgress[lv_team] -= libSCHO_gv_mMHO_ZerglingBanelingSubtractor_C;
                libSCHO_gv_mMHO_ZerglingCount[lv_team] += 1;
            }
        }
    }
}

void libSCHO_gf_MMHOSpawnZerglingsBanelings (int lp_attackLane, int lp_team, region lp_spawnRegion) {
    // Variable Declarations
    int lv_itZergling;
    int lv_itBaneling;

    // Automatic Variable Declarations
    int auto83859561_ae;
    const int auto83859561_ai = 1;
    int autoF4E4979F_val;
    int auto5BCD9153_ae;
    const int auto5BCD9153_ai = 1;
    int auto4352345E_val;

    // Variable Initialization

    // Implementation
    auto83859561_ae = libSCHO_gv_mMHO_ZerglingCount[lp_team];
    lv_itZergling = 1;
    for ( ; ( (auto83859561_ai >= 0 && lv_itZergling <= auto83859561_ae) || (auto83859561_ai < 0 && lv_itZergling >= auto83859561_ae) ) ; lv_itZergling += auto83859561_ai ) {
        libNtve_gf_CreateUnitsWithDefaultFacing(1, "ZergZergling", 0, libGame_gf_ComputerPlayerInTeam(lp_team), RegionRandomPoint(lp_spawnRegion), null);
        UnitGroupAdd(libSCHO_gv_mMHO_AttackGroups[lp_attackLane][libSCHO_gv_mMHO_WaveTracker], UnitLastCreated());
        Wait(RandomFixed(0.0625, 0.125), c_timeGame);
        autoF4E4979F_val = libSCHO_gv_mMHO_WaveTracker;
        if (autoF4E4979F_val == 1) {
            UnitBehaviorAdd(UnitLastCreated(), "Group1", UnitLastCreated(), 1);
        }
        else if (autoF4E4979F_val == 2) {
            UnitBehaviorAdd(UnitLastCreated(), "Group2", UnitLastCreated(), 1);
        }
        else if (autoF4E4979F_val == 3) {
            UnitBehaviorAdd(UnitLastCreated(), "Group3", UnitLastCreated(), 1);
        }
        else {
        }
    }
    auto5BCD9153_ae = libSCHO_gv_mMHO_BanelingCount[lp_team];
    lv_itBaneling = 1;
    for ( ; ( (auto5BCD9153_ai >= 0 && lv_itBaneling <= auto5BCD9153_ae) || (auto5BCD9153_ai < 0 && lv_itBaneling >= auto5BCD9153_ae) ) ; lv_itBaneling += auto5BCD9153_ai ) {
        libNtve_gf_CreateUnitsWithDefaultFacing(1, "ZergBaneling", 0, libGame_gf_ComputerPlayerInTeam(lp_team), RegionRandomPoint(lp_spawnRegion), null);
        UnitGroupAdd(libSCHO_gv_mMHO_AttackGroups[lp_attackLane][libSCHO_gv_mMHO_WaveTracker], UnitLastCreated());
        Wait(RandomFixed(0.0625, 0.125), c_timeGame);
        auto4352345E_val = libSCHO_gv_mMHO_WaveTracker;
        if (auto4352345E_val == 1) {
            UnitBehaviorAdd(UnitLastCreated(), "Group1", UnitLastCreated(), 1);
        }
        else if (auto4352345E_val == 2) {
            UnitBehaviorAdd(UnitLastCreated(), "Group2", UnitLastCreated(), 1);
        }
        else if (auto4352345E_val == 3) {
            UnitBehaviorAdd(UnitLastCreated(), "Group3", UnitLastCreated(), 1);
        }
        else {
        }
    }
}

void libSCHO_gf_MMHOSpawnLanerArchangel (int lp_team, int lp_campIndex) {
    // Variable Declarations
    int lv_lane;
    int lv_region;

    // Automatic Variable Declarations
    int autoCAB42D54_val;

    // Variable Initialization

    // Implementation
    autoCAB42D54_val = lp_campIndex;
    if (autoCAB42D54_val == 5) {
        TimerStart(libSCHO_gv_mMHO_Elevator.lv_elevatorRaiseTimer, (libMapM_gv_jungleCreepCamps[5].lv_defenderRespawnTime - 8), false, c_timeGame);
        libSCHO_gv_mMHO_ArchangelWinningTeam = lp_team;
        libNtve_gf_CreateUnitsWithDefaultFacing(1, "TerranArchangelLaner", c_unitCreateIgnorePlacement, libGame_gf_ComputerPlayerInTeam(lp_team), libSCHO_gv_mMHO_ArchangelSpawnLocationCenter, null);
        libSCHO_gv_mMHO_ArchangelLaner = UnitLastCreated();
        UnitXPAddXP(UnitLastCreated(), null, libSCHO_gv_mMHO_ScalingLevel);
        libSCHO_gf_MMHOCalculateArchangelRallyPoint();
        libGame_gf_CalculateSpawnedMinionGoalPoints(libGame_gf_ComputerPlayerInTeam(lp_team), libSCHO_gv_mMHO_ArchangelSpawnLocationCenter);
        libAIAI_gf_MinionAIStartMinionAI(-1, libSCHO_gv_mMHO_ArchangelLaner, libSCHO_gf_MMHODetermineArchangelPushingLane(lp_team), libGame_gv_spawnedMinionFirstWaypointIndex, true, false, false, libGame_gf_EnemyTeam(lp_team), true);
        UnitSetCustomValue(libSCHO_gv_mMHO_ArchangelLaner, libCore_gf_CustomValueIndex(libCore_ge_CustomValueIndexes_MercLanerGroupIndex), IntToFixed(libSCHO_gv_mMHO_ArchangelAICustomUnitValue));
        SoundPlayForPlayer(SoundLink("Doodad_Merc_Camp_Capture_Ally", -1), libGame_gf_ComputerPlayerInTeam(lp_team), libGame_gf_PlayersOnTeamHeroes(lp_team, false), 100.0, 0.0);
        SoundPlayForPlayer(SoundLink("Doodad_Merc_Camp_Capture_Enemy", -1), libGame_gf_ComputerPlayerInTeam((3 - lp_team)), libGame_gf_PlayersOnTeamHeroes((3 - lp_team), false), 100.0, 0.0);
        SoundPlayForPlayer(SoundLink("Doodad_Merc_Camp_Capture_Ally", -1), libCore_gv_oBSERVER_ObserverUIPlayer, libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer], 100.0, 0.0);
        TriggerEnable(libSCHO_gt_MMHOArchangelDies, true);
        TriggerEnable(libSCHO_gt_MMHOArchangelUpdateMercPath, true);
        libSCHO_gf_MMHOCreateArchangelPathLine(libSCHO_gv_mMHO_ArchangelLaner, true);
    }
    else {
    }
}

void libSCHO_gf_MMHOSetArchangelLanerStartPoints (point lp_lane1, point lp_lane2, point lp_center) {
    // Automatic Variable Declarations
    // Implementation
    libSCHO_gv_mMHO_ArchangelLanerStartPoints[1] = lp_lane1;
    libSCHO_gv_mMHO_ArchangelLanerStartPoints[2] = lp_lane2;
    libSCHO_gv_mMHO_ArchangelSpawnLocationCenter = lp_center;
}

void libSCHO_gf_MMHOCalculateArchangelRallyPoint () {
    // Variable Declarations
    int lv_lane;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    lv_lane = libSCHO_gf_MMHODetermineArchangelPushingLane(libSCHO_gv_mMHO_ArchangelWinningTeam);
    if ((lv_lane == 0)) {
        TriggerDebugOutput(1, StringExternal("Param/Value/lib_SCHO_A7005D13"), true);
    }

    libSCHO_gv_mMHO_ArchangelLanerRallyPoint = libSCHO_gv_mMHO_ArchangelLanerStartPoints[lv_lane];
}

int libSCHO_gf_MMHODetermineArchangelPushingLane (int lp_team) {
    // Variable Declarations
    int lv_teamEnemy;
    int lv_computerEnemy;
    int lv_lane;

    // Automatic Variable Declarations
    int autoDBA5D822_val;

    // Variable Initialization

    // Implementation
    lv_teamEnemy = libGame_gf_EnemyTeam(lp_team);
    lv_computerEnemy = libGame_gf_ComputerPlayerInTeam(lv_teamEnemy);
    autoDBA5D822_val = lp_team;
    if (autoDBA5D822_val == libGame_gv_teamOrderIndex_C) {
        if ((libGame_gf_TownTownIsAlive(6, lv_computerEnemy) == true) && (libGame_gf_TownTownIsAlive(8, lv_computerEnemy) == true)) {
            if ((libSCHO_gf_MMHOTownComparison(6, 8, lv_computerEnemy) > 0)) {
                lv_lane = 1;
            }
            else if ((libSCHO_gf_MMHOTownComparison(6, 8, lv_computerEnemy) < 0)) {
                lv_lane = 2;
            }
            else if (true) {
                lv_lane = 0;
            }
        }
        else if ((libGame_gf_TownTownIsAlive(6, lv_computerEnemy) == true)) {
            lv_lane = 1;
        }
        else if ((libGame_gf_TownTownIsAlive(8, lv_computerEnemy) == true)) {
            lv_lane = 2;
        }
        else if ((libGame_gf_TownTownIsAlive(5, lv_computerEnemy) == true) && (libGame_gf_TownTownIsAlive(7, lv_computerEnemy) == true)) {
            if ((libSCHO_gf_MMHOTownComparison(5, 7, lv_computerEnemy) > 0)) {
                lv_lane = 1;
            }
            else if ((libSCHO_gf_MMHOTownComparison(5, 7, lv_computerEnemy) < 0)) {
                lv_lane = 2;
            }
            else if (true) {
                lv_lane = 0;
            }
        }
        else if ((libGame_gf_TownTownIsAlive(5, lv_computerEnemy) == true)) {
            lv_lane = 1;
        }
        else if ((libGame_gf_TownTownIsAlive(7, lv_computerEnemy) == true)) {
            lv_lane = 2;
        }
        else if (true) {
            lv_lane = 0;
        }
    }
    else if (autoDBA5D822_val == libGame_gv_teamChaosIndex_C) {
        if ((libGame_gf_TownTownIsAlive(2, lv_computerEnemy) == true) && (libGame_gf_TownTownIsAlive(4, lv_computerEnemy) == true)) {
            if ((libSCHO_gf_MMHOTownComparison(2, 4, lv_computerEnemy) > 0)) {
                lv_lane = 1;
            }
            else if ((libSCHO_gf_MMHOTownComparison(2, 4, lv_computerEnemy) < 0)) {
                lv_lane = 2;
            }
            else if (true) {
                lv_lane = 0;
            }
        }
        else if ((libGame_gf_TownTownIsAlive(2, lv_computerEnemy) == true)) {
            lv_lane = 1;
        }
        else if ((libGame_gf_TownTownIsAlive(4, lv_computerEnemy) == true)) {
            lv_lane = 2;
        }
        else if ((libGame_gf_TownTownIsAlive(1, lv_computerEnemy) == true) && (libGame_gf_TownTownIsAlive(3, lv_computerEnemy) == true)) {
            if ((libSCHO_gf_MMHOTownComparison(1, 3, lv_computerEnemy) > 0)) {
                lv_lane = 1;
            }
            else if ((libSCHO_gf_MMHOTownComparison(1, 3, lv_computerEnemy) < 0)) {
                lv_lane = 2;
            }
            else if (true) {
                lv_lane = 0;
            }
        }
        else if ((libGame_gf_TownTownIsAlive(1, lv_computerEnemy) == true)) {
            lv_lane = 1;
        }
        else if ((libGame_gf_TownTownIsAlive(3, lv_computerEnemy) == true)) {
            lv_lane = 2;
        }
        else if (true) {
            lv_lane = 0;
        }
    }
    else {
    }
    if ((lv_lane == 0)) {
        lv_lane = RandomInt(1, 2);
    }

    return lv_lane;
}

int libSCHO_gf_MMHOTownComparison (int lp_town1, int lp_town2, int lp_player) {
    // Variable Declarations
    unitgroup lv_group;
    unit lv_itStructure;
    fixed lv_hPTotal;
    fixed lv_townHP1;
    fixed lv_townHP2;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_group = UnitGroupEmpty();

    // Implementation
    if ((libGame_gf_TownTownIsAlive(lp_town1, lp_player) == false) && (libGame_gf_TownTownIsAlive(lp_town2, lp_player) == false)) {
        return 0;
    }

    if ((libGame_gf_TownTownIsAlive(lp_town1, lp_player) == false)) {
        return -1;
    }

    if ((libGame_gf_TownTownIsAlive(lp_town2, lp_player) == false)) {
        return 1;
    }

    if ((UnitIsAlive(libGame_gf_TownTownHall(lp_town1)) == true) && (UnitIsAlive(libGame_gf_TownTownHall(lp_town2)) == false)) {
        return 1;
    }

    if ((UnitIsAlive(libGame_gf_TownTownHall(lp_town1)) == false) && (UnitIsAlive(libGame_gf_TownTownHall(lp_town2)) == true)) {
        return -1;
    }

    lv_townHP1 = libSCHO_gf_MMHOTownHealth(lp_town1, lp_player);
    lv_townHP2 = libSCHO_gf_MMHOTownHealth(lp_town2, lp_player);
    if (((lv_townHP1 - lv_townHP2) > 0.0)) {
        return 1;
    }

    if (((lv_townHP2 - lv_townHP1) > 0.0)) {
        return -1;
    }

    return 0;
}

fixed libSCHO_gf_MMHOTownHealth (int lp_town, int lp_player) {
    // Variable Declarations
    unitgroup lv_group;
    unit lv_itStructure;
    fixed lv_hPTotal;

    // Automatic Variable Declarations
    unitgroup auto29A3DD09_g;
    int auto29A3DD09_u;

    // Variable Initialization
    lv_group = UnitGroupEmpty();

    // Implementation
    lv_group = UnitGroup(null, lp_player, libGame_gv_townTownData[lp_town].lv_townRegion, UnitFilter((1 << c_targetFilterStructure), 0, (1 << c_targetFilterNoMinionAggro) | (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)) | (1 << (c_targetFilterInvulnerable - 32))), 0);
    auto29A3DD09_g = lv_group;
    auto29A3DD09_u = UnitGroupCount(auto29A3DD09_g, c_unitCountAll);
    for (;; auto29A3DD09_u -= 1) {
        lv_itStructure = UnitGroupUnitFromEnd(auto29A3DD09_g, auto29A3DD09_u);
        if (lv_itStructure == null) { break; }
        if ((UnitGetType(lv_itStructure) != "TownMoonwell") && (UnitGetType(lv_itStructure) != "TownMoonwellL2") && (UnitGetType(lv_itStructure) != "TownMoonwellL3")) {
            lv_hPTotal += UnitGetPropertyFixed(lv_itStructure, c_unitPropLife, c_unitPropCurrent);
        }

    }
    return lv_hPTotal;
}

trigger auto_libSCHO_gf_MMHOCreateArchangelPathLine_Trigger = null;
unit auto_libSCHO_gf_MMHOCreateArchangelPathLine_lp_unit;
bool auto_libSCHO_gf_MMHOCreateArchangelPathLine_lp_new_Path;

void libSCHO_gf_MMHOCreateArchangelPathLine (unit lp_unit, bool lp_new_Path) {
    auto_libSCHO_gf_MMHOCreateArchangelPathLine_lp_unit = lp_unit;
    auto_libSCHO_gf_MMHOCreateArchangelPathLine_lp_new_Path = lp_new_Path;

    if (auto_libSCHO_gf_MMHOCreateArchangelPathLine_Trigger == null) {
        auto_libSCHO_gf_MMHOCreateArchangelPathLine_Trigger = TriggerCreate("auto_libSCHO_gf_MMHOCreateArchangelPathLine_TriggerFunc");
    }

    TriggerExecute(auto_libSCHO_gf_MMHOCreateArchangelPathLine_Trigger, false, false);
}

bool auto_libSCHO_gf_MMHOCreateArchangelPathLine_TriggerFunc (bool testConds, bool runActions) {
    unit lp_unit = auto_libSCHO_gf_MMHOCreateArchangelPathLine_lp_unit;
    bool lp_new_Path = auto_libSCHO_gf_MMHOCreateArchangelPathLine_lp_new_Path;

    // Variable Declarations
    int lv_currentLane;
    int lv_itWaypoint;

    // Automatic Variable Declarations
    int auto7CA8A2BE_val;

    // Variable Initialization

    // Implementation
    if ((UnitIsAlive(lp_unit) == false)) {
        return true;
    }

    lv_currentLane = libAIAI_gf_MinionAIGetLaneForMinion(lp_unit);
    lv_itWaypoint = libAIAI_gf_MinionAIGetNextWaypointIndexForMinion(lp_unit);
    if ((lp_new_Path == false)) {
        if ((libSCHO_gv_mMHO_ArchangelCurrentPathIndex < libSCHO_gv_mMHO_ArchangelPathIndexMax)) {
            PathSetWayPointIndexStart(libSCHO_gv_mMHO_ArchangelLanerPathLine, libSCHO_gv_mMHO_ArchangelCurrentPathIndex);
        }
        else if ((libSCHO_gv_mMHO_ArchangelCurrentPathIndex >= libSCHO_gv_mMHO_ArchangelPathIndexMax)) {
            PathDestroy(libSCHO_gv_mMHO_ArchangelLanerPathLine);
            PathCreateForUnit(PlayerGroupAll(), lp_unit);
            libSCHO_gv_mMHO_ArchangelLanerPathLine = PathLastCreated();
            PathSetLineTexture(libSCHO_gv_mMHO_ArchangelLanerPathLine, c_pathLocationMinimap, "Assets\\Textures\\storm_waypointline.dds");
            PathSetVisible(libSCHO_gv_mMHO_ArchangelLanerPathLine, c_pathLocationWorld, false);
            PathSetOwnerPlayerId(libSCHO_gv_mMHO_ArchangelLanerPathLine, UnitGetOwner(lp_unit));
            PathSetDestinationUnit(libSCHO_gv_mMHO_ArchangelLanerPathLine, libGame_gv_teams[libAIAI_gf_MinionAIGetTeamToAttackForMinion(lp_unit)].lv_core);
        }
        return true;
    }

    PathCreateForUnit(PlayerGroupAll(), lp_unit);
    libSCHO_gv_mMHO_ArchangelLanerPathLine = PathLastCreated();
    PathSetLineTexture(libSCHO_gv_mMHO_ArchangelLanerPathLine, c_pathLocationMinimap, "Assets\\Textures\\storm_waypointline.dds");
    PathSetVisible(libSCHO_gv_mMHO_ArchangelLanerPathLine, c_pathLocationWorld, false);
    auto7CA8A2BE_val = libAIAI_gf_MinionAIGetTeamToAttackForMinion(lp_unit);
    if (auto7CA8A2BE_val == libGame_gv_teamChaosIndex_C) {
        PathSetOwnerPlayerId(libSCHO_gv_mMHO_ArchangelLanerPathLine, libCore_gv_cOMPUTER_TeamOrder);
        PathSetDestinationUnit(libSCHO_gv_mMHO_ArchangelLanerPathLine, libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_core);
        while ((lv_itWaypoint < (libGame_gv_laneData[lv_currentLane].lv_waypointCount - 1))) {
            PathAddWayPoint(libSCHO_gv_mMHO_ArchangelLanerPathLine, libGame_gv_laneData[lv_currentLane].lv_waypoints[lv_itWaypoint]);
            lv_itWaypoint += 1;
            libSCHO_gv_mMHO_ArchangelPathIndexMax += 1;
        }
    }
    else if (auto7CA8A2BE_val == libGame_gv_teamOrderIndex_C) {
        PathSetOwnerPlayerId(libSCHO_gv_mMHO_ArchangelLanerPathLine, libCore_gv_cOMPUTER_TeamChaos);
        PathSetDestinationUnit(libSCHO_gv_mMHO_ArchangelLanerPathLine, libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_core);
        while ((lv_itWaypoint > 1)) {
            PathAddWayPoint(libSCHO_gv_mMHO_ArchangelLanerPathLine, libGame_gv_laneData[lv_currentLane].lv_waypoints[lv_itWaypoint]);
            lv_itWaypoint -= 1;
            libSCHO_gv_mMHO_ArchangelPathIndexMax += 1;
        }
    }
    else {
    }
    return true;
}

void libSCHO_gf_MMHOElevatorAddRemoveUnpathable (bool lp_addRemove) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_addRemove == true)) {
        if ((libSCHO_gv_mMHO_ArchangelElevatorBlockerUnit == null)) {
            libNtve_gf_CreateUnitsWithDefaultFacing(1, "ArchangelElevatorPathingBlocker", c_unitCreateIgnorePlacement, libCore_gv_cOMPUTER_Neutral, libSCHO_gv_mMHO_ArchangelSpawnLocationCenter, null);
            libSCHO_gv_mMHO_ArchangelElevatorBlockerUnit = UnitLastCreated();
        }

    }
    else {
        UnitRemove(libSCHO_gv_mMHO_ArchangelElevatorBlockerUnit);
        libSCHO_gv_mMHO_ArchangelElevatorBlockerUnit = null;
        libSCHO_gv_mMHO_ArchangelElevator_ShouldBeLowered = false;
    }
}

trigger auto_libSCHO_gf_MMHODelayElevatorLowering_Trigger = null;

void libSCHO_gf_MMHODelayElevatorLowering () {
    if (auto_libSCHO_gf_MMHODelayElevatorLowering_Trigger == null) {
        auto_libSCHO_gf_MMHODelayElevatorLowering_Trigger = TriggerCreate("auto_libSCHO_gf_MMHODelayElevatorLowering_TriggerFunc");
    }

    TriggerExecute(auto_libSCHO_gf_MMHODelayElevatorLowering_Trigger, false, false);
}

bool auto_libSCHO_gf_MMHODelayElevatorLowering_TriggerFunc (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_itUnit;
    unit lv_itHeroUnit;

    // Automatic Variable Declarations
    const int autoF20BAEF3_n = 5;
    int autoF20BAEF3_i;
    unitgroup auto6C343D0B_g;
    int auto6C343D0B_u;

    // Variable Initialization

    // Implementation
    Wait(5.0, c_timeGame);
    libSCHO_gv_mMHO_ArchangelElevator_ShouldBeLowered = true;
    while (!(((libSCHO_gv_mMHO_ArchangelElevator_ShouldBeLowered == false) || ((UnitGroupCount(UnitGroup(null, c_playerAny, libSCHO_gv_mMHO_ArchangelElevatorRegion, UnitFilter((1 << c_targetFilterHeroic), 0, 0, 0), 0), c_unitCountAlive) == 0) && (UnitGroupCount(UnitGroup(null, c_playerAny, libSCHO_gv_mMHO_ArchangelElevatorRegion, UnitFilter(0, (1 << (c_targetFilterSummoned - 32)), 0, 0), 0), c_unitCountAlive) == 0) && (UnitGroupCount(UnitGroup(null, c_playerAny, libSCHO_gv_mMHO_ArchangelElevatorRegion, UnitFilter((1 << c_targetFilterMinion), 0, 0, 0), 0), c_unitCountAlive) == 0) && (UnitGroupCount(UnitGroup(null, c_playerAny, libSCHO_gv_mMHO_ArchangelElevatorRegion, UnitFilter((1 << c_targetFilterCreep), 0, 0, 0), 0), c_unitCountAlive) == 0))))) {
        Wait(0.0625, c_timeGame);
    }
    if ((libSCHO_gv_mMHO_ArchangelElevator_ShouldBeLowered == true)) {
        libSCHO_gv_mMHO_Elevator.lv_elevatorWasLowered = true;
        libSCHO_gf_MMHOElevatorAddRemoveUnpathable(true);
        ActorSend(ActorFromDoodad(libSCHO_gv_mMHO_ArchangelElevator), "Signal Down");
        for (autoF20BAEF3_i = 1; autoF20BAEF3_i <= autoF20BAEF3_n; autoF20BAEF3_i += 1) {
            auto6C343D0B_g = UnitGroup(null, c_playerAny, libSCHO_gv_mMHO_ArchangelElevatorRegion, libCore_gv_filtersHeroic, 0);
            auto6C343D0B_u = UnitGroupCount(auto6C343D0B_g, c_unitCountAll);
            for (;; auto6C343D0B_u -= 1) {
                lv_itHeroUnit = UnitGroupUnitFromEnd(auto6C343D0B_g, auto6C343D0B_u);
                if (lv_itHeroUnit == null) { break; }
                UnitCreateEffectUnit(lv_itHeroUnit, "HeroGenericMissileInterruptLaunchMissile", lv_itHeroUnit);
            }
            Wait(0.0625, c_timeGame);
        }
    }
    else {
        libSCHO_gv_mMHO_Elevator.lv_elevatorWasLowered = false;
    }
    return true;
}

trigger auto_libSCHO_gf_MMHOCreateDropPod_Trigger = null;
point auto_libSCHO_gf_MMHOCreateDropPod_lp_dropPodPosition;
int auto_libSCHO_gf_MMHOCreateDropPod_lp_dropPodOwner;

void libSCHO_gf_MMHOCreateDropPod (point lp_dropPodPosition, int lp_dropPodOwner) {
    auto_libSCHO_gf_MMHOCreateDropPod_lp_dropPodPosition = lp_dropPodPosition;
    auto_libSCHO_gf_MMHOCreateDropPod_lp_dropPodOwner = lp_dropPodOwner;

    if (auto_libSCHO_gf_MMHOCreateDropPod_Trigger == null) {
        auto_libSCHO_gf_MMHOCreateDropPod_Trigger = TriggerCreate("auto_libSCHO_gf_MMHOCreateDropPod_TriggerFunc");
    }

    TriggerExecute(auto_libSCHO_gf_MMHOCreateDropPod_Trigger, false, false);
}

bool auto_libSCHO_gf_MMHOCreateDropPod_TriggerFunc (bool testConds, bool runActions) {
    point lp_dropPodPosition = auto_libSCHO_gf_MMHOCreateDropPod_lp_dropPodPosition;
    int lp_dropPodOwner = auto_libSCHO_gf_MMHOCreateDropPod_lp_dropPodOwner;

    // Variable Declarations
    const int lv_zerglingsPerDropPod_C = 3;
    const int lv_hydralisksPerDropPod_C = 1;
    const fixed lv_pathablePointSearchRadius_C = 6.0;
    point lv_pathablePoint;

    // Automatic Variable Declarations
    const int auto72A1A2A5_n = lv_zerglingsPerDropPod_C;
    int auto72A1A2A5_i;
    const int autoD8D71635_n = lv_hydralisksPerDropPod_C;
    int autoD8D71635_i;

    // Variable Initialization
    lv_pathablePoint = UnitTypePlacementFromPoint("ZergUltralisk", lp_dropPodOwner, lp_dropPodPosition, lv_pathablePointSearchRadius_C);

    // Implementation
    PlayerCreateEffectPoint(lp_dropPodOwner, "BraxisDropPodCreatePersistent", lp_dropPodPosition);
    Wait(1.4, c_timeGame);
    for (auto72A1A2A5_i = 1; auto72A1A2A5_i <= auto72A1A2A5_n; auto72A1A2A5_i += 1) {
        libNtve_gf_CreateUnitsWithDefaultFacing(1, "ZergZergling", 0, lp_dropPodOwner, lp_dropPodPosition, null);
        UnitXPAddXP(UnitLastCreated(), null, libSCHO_gv_mMHO_ScalingLevel);
        UnitCreateAIThinkTree(UnitLastCreated());
    }
    for (autoD8D71635_i = 1; autoD8D71635_i <= autoD8D71635_n; autoD8D71635_i += 1) {
        libNtve_gf_CreateUnitsWithDefaultFacing(1, "ZergHydralisk", 0, lp_dropPodOwner, lp_dropPodPosition, null);
        UnitXPAddXP(UnitLastCreated(), null, libSCHO_gv_mMHO_ScalingLevel);
        UnitCreateAIThinkTree(UnitLastCreated());
    }
    return true;
}

trigger auto_libSCHO_gf_MMHODisplayRegenGlobeGeneratorTimer_Trigger = null;
unit auto_libSCHO_gf_MMHODisplayRegenGlobeGeneratorTimer_lp_unit;

void libSCHO_gf_MMHODisplayRegenGlobeGeneratorTimer (unit lp_unit) {
    auto_libSCHO_gf_MMHODisplayRegenGlobeGeneratorTimer_lp_unit = lp_unit;

    if (auto_libSCHO_gf_MMHODisplayRegenGlobeGeneratorTimer_Trigger == null) {
        auto_libSCHO_gf_MMHODisplayRegenGlobeGeneratorTimer_Trigger = TriggerCreate("auto_libSCHO_gf_MMHODisplayRegenGlobeGeneratorTimer_TriggerFunc");
    }

    TriggerExecute(auto_libSCHO_gf_MMHODisplayRegenGlobeGeneratorTimer_Trigger, false, false);
}

bool auto_libSCHO_gf_MMHODisplayRegenGlobeGeneratorTimer_TriggerFunc (bool testConds, bool runActions) {
    unit lp_unit = auto_libSCHO_gf_MMHODisplayRegenGlobeGeneratorTimer_lp_unit;

    // Automatic Variable Declarations
    // Implementation
    TextExpressionSetToken("Param/Expression/lib_SCHO_D818FDB9", "A", TextTimeFormat(StringToText("<min2/>:<sec2/>"), FixedToInt(UnitBehaviorDuration(lp_unit, "GenerateRegenGlobe"))));
    TextTagCreate(TextExpressionAssemble("Param/Expression/lib_SCHO_D818FDB9"), 24, UnitGetPosition(lp_unit), 2.0, true, false, PlayerGroupAll());
    while ((UnitHasBehavior2(lp_unit, "GenerateRegenGlobe") == true)) {
        TextExpressionSetToken("Param/Expression/lib_SCHO_4B812242", "A", TextTimeFormat(StringToText("<min2/>:<sec2/>"), FixedToInt(UnitBehaviorDuration(lp_unit, "GenerateRegenGlobe"))));
        TextTagSetText(TextTagLastCreated(), TextExpressionAssemble("Param/Expression/lib_SCHO_4B812242"));
        Wait(1.0, c_timeGame);
    }
    TextTagDestroy(TextTagLastCreated());
    return true;
}

void libSCHO_gf_MMHORegenGlobeCoolupTime () {
    // Automatic Variable Declarations
    unitgroup auto126029DC_g;
    int auto126029DC_u;
    unit auto126029DC_var;

    // Implementation
    auto126029DC_g = UnitGroup("RegenGlobeGenerator", c_playerAny, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    auto126029DC_u = UnitGroupCount(auto126029DC_g, c_unitCountAll);
    for (;; auto126029DC_u -= 1) {
        auto126029DC_var = UnitGroupUnitFromEnd(auto126029DC_g, auto126029DC_u);
        if (auto126029DC_var == null) { break; }
        UnitBehaviorSetDuration(auto126029DC_var, "GenerateRegenGlobe", libSCHO_gv_mMHO_RegenGlobeCoolupTime_C);
        libNtve_gf_SendActorMessageToUnit(auto126029DC_var, "Signal RegenGlobeDurationRefreshed");
    }
}

void libSCHO_gf_MMHOEndofMatchAwardZergCrusherModifyValuesandReport (int lp_player, fixed lp_damage) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_player > 0) && (lp_player <= libCore_gv_bALMaxPlayers)) {
        libSCHO_gv_mMHOEndofMatchAwardZergCrusherValue[lp_player] += lp_damage;
        libGame_gf_SendMapSpecificAwardEvent(lp_player, libSCHO_gv_mMHOEndofMatchAwardZergCrusherValue[lp_player], false);
        libGame_gf_ScoreValuesReportRealValueAndLog(lp_player, "DamageDoneToZerg", libSCHO_gv_mMHOEndofMatchAwardZergCrusherValue[lp_player]);
    }

}

trigger auto_libSCHO_gf_MMHOTransmissionBeaconsActivating_Trigger = null;

void libSCHO_gf_MMHOTransmissionBeaconsActivating () {
    if (auto_libSCHO_gf_MMHOTransmissionBeaconsActivating_Trigger == null) {
        auto_libSCHO_gf_MMHOTransmissionBeaconsActivating_Trigger = TriggerCreate("auto_libSCHO_gf_MMHOTransmissionBeaconsActivating_TriggerFunc");
    }

    TriggerExecute(auto_libSCHO_gf_MMHOTransmissionBeaconsActivating_Trigger, false, false);
}

bool auto_libSCHO_gf_MMHOTransmissionBeaconsActivating_TriggerFunc (bool testConds, bool runActions) {
    // Variable Declarations
    playergroup lv_groupOrder;
    playergroup lv_groupChaos;
    playergroup lv_groupObserver;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_groupOrder = PlayerGroupEmpty();
    lv_groupChaos = PlayerGroupEmpty();
    lv_groupObserver = PlayerGroupEmpty();

    // Implementation
    if ((libGame_gv_gameOver == true)) {
        return true;
    }

    TriggerQueueEnter();
    UserDataResetType("MapVOEvent");
    if ((libSCHO_gv_mMHO_NumberOfEventsFired == 1)) {
        UserDataSetInt("MapVOEvent", "Holdout - First Beacons Activating", "Value", 1, 1);
    }
    else {
        UserDataSetInt("MapVOEvent", "Holdout - Subsequent Beacons Activating", "Value", 1, 1);
    }
    ConversationDataRun("HoldoutVO", PlayerGroupAll(), c_conversationSkipNone, false);
    libCore_gf_WaitForConversationToFinish();
    TriggerQueueExit();
    return true;
}

trigger auto_libSCHO_gf_MMHOTransmissionBeaconsActive_Trigger = null;

void libSCHO_gf_MMHOTransmissionBeaconsActive () {
    if (auto_libSCHO_gf_MMHOTransmissionBeaconsActive_Trigger == null) {
        auto_libSCHO_gf_MMHOTransmissionBeaconsActive_Trigger = TriggerCreate("auto_libSCHO_gf_MMHOTransmissionBeaconsActive_TriggerFunc");
    }

    TriggerExecute(auto_libSCHO_gf_MMHOTransmissionBeaconsActive_Trigger, false, false);
}

bool auto_libSCHO_gf_MMHOTransmissionBeaconsActive_TriggerFunc (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Implementation
    if ((libGame_gv_gameOver == true)) {
        return true;
    }

    TriggerQueueEnter();
    UserDataResetType("MapVOEvent");
    if ((libSCHO_gv_mMHO_NumberOfEventsFired == 1)) {
        UserDataSetInt("MapVOEvent", "Holdout - First Beacons Active", "Value", 1, 1);
    }
    else {
        UserDataSetInt("MapVOEvent", "Holdout - Subsequent Beacons Active", "Value", 1, 1);
    }
    ConversationDataRun("HoldoutVO", PlayerGroupAll(), c_conversationSkipNone, false);
    libCore_gf_WaitForConversationToFinish();
    TriggerQueueExit();
    return true;
}

trigger auto_libSCHO_gf_MMHOTransmissionZergAttacking_Trigger = null;

void libSCHO_gf_MMHOTransmissionZergAttacking () {
    if (auto_libSCHO_gf_MMHOTransmissionZergAttacking_Trigger == null) {
        auto_libSCHO_gf_MMHOTransmissionZergAttacking_Trigger = TriggerCreate("auto_libSCHO_gf_MMHOTransmissionZergAttacking_TriggerFunc");
    }

    TriggerExecute(auto_libSCHO_gf_MMHOTransmissionZergAttacking_Trigger, false, false);
}

bool auto_libSCHO_gf_MMHOTransmissionZergAttacking_TriggerFunc (bool testConds, bool runActions) {
    int init_i;

    // Variable Declarations
    bool[libCore_gv_bALMaxTeams + 1] lv_transmissionAvailableForTeams;
    unit lv_foremostZergUnit;
    bool lv_isForemostZergUnitInCombat;
    unitgroup lv_nearbyDefendingHeroes;
    int lv_teamIndex;

    // Automatic Variable Declarations
    const int auto06308D99_ae = libCore_gv_bALMaxTeams;
    const int auto06308D99_ai = 1;
    int autoFCE8A238_val;

    // Variable Initialization
    for (init_i = 0; init_i <= libCore_gv_bALMaxTeams; init_i += 1) {
        lv_transmissionAvailableForTeams[init_i] = true;
    }
    lv_nearbyDefendingHeroes = UnitGroupEmpty();

    // Implementation
    libSCHO_gv_mMHO_ReminderTransmissions[libGame_gv_teamOrderIndex_C] = c_invalidTransmissionId;
    libSCHO_gv_mMHO_ReminderTransmissions[libGame_gv_teamChaosIndex_C] = c_invalidTransmissionId;
    Wait(25.0, c_timeGame);
    if ((libGame_gv_gameOver == true)) {
        return true;
    }

    while (true) {
        if ((lv_transmissionAvailableForTeams[libGame_gv_teamOrderIndex_C] == false) && (lv_transmissionAvailableForTeams[libGame_gv_teamChaosIndex_C] == false)) {
            return true;
        }

        if ((libGame_gv_gameOver == true)) {
            return true;
        }

        lv_teamIndex = 1;
        for ( ; ( (auto06308D99_ai >= 0 && lv_teamIndex <= auto06308D99_ae) || (auto06308D99_ai < 0 && lv_teamIndex >= auto06308D99_ae) ) ; lv_teamIndex += auto06308D99_ai ) {
            if ((lv_transmissionAvailableForTeams[lv_teamIndex] == false)) {
                continue;
            }

            if ((UnitGroupCount(UnitGroupFilter("ZergUltralisk", c_playerAny, libSCHO_gv_mMHO_AttackGroups[libGame_gf_EnemyTeam(lv_teamIndex)][1], UnitFilter(0, 0, 0, (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0), c_unitCountAlive) == 0) && (UnitGroupCount(UnitGroupFilter("ZergGuardian", c_playerAny, libSCHO_gv_mMHO_AttackGroups[libGame_gf_EnemyTeam(lv_teamIndex)][1], UnitFilter(0, 0, 0, (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0), c_unitCountAlive) == 0) && (UnitGroupCount(UnitGroupFilter(null, c_playerAny, libSCHO_gv_mMHO_AttackGroups[libGame_gf_EnemyTeam(lv_teamIndex)][1], UnitFilter(0, 0, 0, (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0), c_unitCountAlive) < 10)) {
                lv_transmissionAvailableForTeams[lv_teamIndex] = false;
            }
            else {
                lv_foremostZergUnit = UnitGroupClosestToPoint(libSCHO_gv_mMHO_AttackGroups[libGame_gf_EnemyTeam(lv_teamIndex)][1], UnitGetPosition(libGame_gv_teams[lv_teamIndex].lv_core));
                lv_isForemostZergUnitInCombat = (OrderGetAbilityCommand(UnitOrder(lv_foremostZergUnit, 0)) == AbilityCommand("attack", 0));
                lv_nearbyDefendingHeroes = libNtve_gf_UnitsInRegionWithAllianceToPlayerMatchingCondition(null, "", "", UnitGetOwner(lv_foremostZergUnit), c_unitAllianceEnemy, RegionCircle(UnitGetPosition(lv_foremostZergUnit), 15.0), libCore_gv_filtersHeroic, 1);
                if ((lv_isForemostZergUnitInCombat == true) && (UnitGroupCount(lv_nearbyDefendingHeroes, c_unitCountAlive) == 0)) {
                    autoFCE8A238_val = RandomInt(1, 9);
                    if (autoFCE8A238_val == 1) {
                        TransmissionSendForPlayerSelect(libGame_gf_PlayersOnTeamHeroes(lv_teamIndex, false), TransmissionSource(), c_invalidPortraitId, "", "Talk", SoundLinkNoIndex(ConversationDataGetSound("HoldoutVO|Line00032", false)), null, null, 0.0, c_transmissionDurationAdd, false, c_maxPlayers, false);
                    }
                    else if (autoFCE8A238_val == 2) {
                        TransmissionSendForPlayerSelect(libGame_gf_PlayersOnTeamHeroes(lv_teamIndex, false), TransmissionSource(), c_invalidPortraitId, "", "Talk", SoundLinkNoIndex(ConversationDataGetSound("HoldoutVO|Line00033", false)), null, null, 0.0, c_transmissionDurationAdd, false, c_maxPlayers, false);
                    }
                    else if (autoFCE8A238_val == 3) {
                        TransmissionSendForPlayerSelect(libGame_gf_PlayersOnTeamHeroes(lv_teamIndex, false), TransmissionSource(), c_invalidPortraitId, "", "Talk", SoundLinkNoIndex(ConversationDataGetSound("HoldoutVO|Line00034", false)), null, null, 0.0, c_transmissionDurationAdd, false, c_maxPlayers, false);
                    }
                    else if (autoFCE8A238_val == 4) {
                        TransmissionSendForPlayerSelect(libGame_gf_PlayersOnTeamHeroes(lv_teamIndex, false), TransmissionSource(), c_invalidPortraitId, "", "Talk", SoundLinkNoIndex(ConversationDataGetSound("HoldoutVO|Line00035", false)), null, null, 0.0, c_transmissionDurationAdd, false, c_maxPlayers, false);
                    }
                    else if (autoFCE8A238_val == 5) {
                        TransmissionSendForPlayerSelect(libGame_gf_PlayersOnTeamHeroes(lv_teamIndex, false), TransmissionSource(), c_invalidPortraitId, "", "Talk", SoundLinkNoIndex(ConversationDataGetSound("HoldoutVO|Line00036", false)), null, null, 0.0, c_transmissionDurationAdd, false, c_maxPlayers, false);
                    }
                    else if (autoFCE8A238_val == 6) {
                        TransmissionSendForPlayerSelect(libGame_gf_PlayersOnTeamHeroes(lv_teamIndex, false), TransmissionSource(), c_invalidPortraitId, "", "Talk", SoundLinkNoIndex(ConversationDataGetSound("HoldoutVO|Line00037", false)), null, null, 0.0, c_transmissionDurationAdd, false, c_maxPlayers, false);
                    }
                    else if (autoFCE8A238_val == 7) {
                        TransmissionSendForPlayerSelect(libGame_gf_PlayersOnTeamHeroes(lv_teamIndex, false), TransmissionSource(), c_invalidPortraitId, "", "Talk", SoundLinkNoIndex(ConversationDataGetSound("HoldoutVO|Line00038", false)), null, null, 0.0, c_transmissionDurationAdd, false, c_maxPlayers, false);
                    }
                    else if (autoFCE8A238_val == 8) {
                        TransmissionSendForPlayerSelect(libGame_gf_PlayersOnTeamHeroes(lv_teamIndex, false), TransmissionSource(), c_invalidPortraitId, "", "Talk", SoundLinkNoIndex(ConversationDataGetSound("HoldoutVO|Line00039", false)), null, null, 0.0, c_transmissionDurationAdd, false, c_maxPlayers, false);
                    }
                    else if (autoFCE8A238_val == 9) {
                        TransmissionSendForPlayerSelect(libGame_gf_PlayersOnTeamHeroes(lv_teamIndex, false), TransmissionSource(), c_invalidPortraitId, "", "Talk", SoundLinkNoIndex(ConversationDataGetSound("HoldoutVO|Line00053", false)), null, null, 0.0, c_transmissionDurationAdd, false, c_maxPlayers, false);
                    }
                    else {
                    }
                    lv_transmissionAvailableForTeams[lv_teamIndex] = false;
                    libSCHO_gv_mMHO_ReminderTransmissions[lv_teamIndex] = TransmissionLastSent();
                }

            }
        }
        Wait(1.0, c_timeGame);
    }
    return true;
}

trigger auto_libSCHO_gf_MMHOTransmissionAllZergDead_Trigger = null;

void libSCHO_gf_MMHOTransmissionAllZergDead () {
    if (auto_libSCHO_gf_MMHOTransmissionAllZergDead_Trigger == null) {
        auto_libSCHO_gf_MMHOTransmissionAllZergDead_Trigger = TriggerCreate("auto_libSCHO_gf_MMHOTransmissionAllZergDead_TriggerFunc");
    }

    TriggerExecute(auto_libSCHO_gf_MMHOTransmissionAllZergDead_Trigger, false, false);
}

bool auto_libSCHO_gf_MMHOTransmissionAllZergDead_TriggerFunc (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Implementation
    if ((libGame_gv_gameOver == true)) {
        return true;
    }

    if ((libSCHO_gv_mMHO_ReminderTransmissions[libGame_gv_teamOrderIndex_C] != c_invalidTransmissionId)) {
        TransmissionClear(libSCHO_gv_mMHO_ReminderTransmissions[libGame_gv_teamOrderIndex_C]);
    }

    if ((libSCHO_gv_mMHO_ReminderTransmissions[libGame_gv_teamChaosIndex_C] != c_invalidTransmissionId)) {
        TransmissionClear(libSCHO_gv_mMHO_ReminderTransmissions[libGame_gv_teamChaosIndex_C]);
    }

    TriggerQueueEnter();
    UserDataResetType("MapVOEvent");
    UserDataSetInt("MapVOEvent", "Holdout - Zerg Dead", "Value", 1, 1);
    ConversationDataRun("HoldoutVO", PlayerGroupAll(), c_conversationSkipNone, false);
    libCore_gf_WaitForConversationToFinish();
    TriggerQueueExit();
    return true;
}

trigger auto_libSCHO_gf_MMHOTransmissionBeaconsFullyCaptured_Trigger = null;
fixed auto_libSCHO_gf_MMHOTransmissionBeaconsFullyCaptured_lp_orderTeamProgress;
fixed auto_libSCHO_gf_MMHOTransmissionBeaconsFullyCaptured_lp_chaosTeamProgress;

void libSCHO_gf_MMHOTransmissionBeaconsFullyCaptured (fixed lp_orderTeamProgress, fixed lp_chaosTeamProgress) {
    auto_libSCHO_gf_MMHOTransmissionBeaconsFullyCaptured_lp_orderTeamProgress = lp_orderTeamProgress;
    auto_libSCHO_gf_MMHOTransmissionBeaconsFullyCaptured_lp_chaosTeamProgress = lp_chaosTeamProgress;

    if (auto_libSCHO_gf_MMHOTransmissionBeaconsFullyCaptured_Trigger == null) {
        auto_libSCHO_gf_MMHOTransmissionBeaconsFullyCaptured_Trigger = TriggerCreate("auto_libSCHO_gf_MMHOTransmissionBeaconsFullyCaptured_TriggerFunc");
    }

    TriggerExecute(auto_libSCHO_gf_MMHOTransmissionBeaconsFullyCaptured_Trigger, false, false);
}

bool auto_libSCHO_gf_MMHOTransmissionBeaconsFullyCaptured_TriggerFunc (bool testConds, bool runActions) {
    fixed lp_orderTeamProgress = auto_libSCHO_gf_MMHOTransmissionBeaconsFullyCaptured_lp_orderTeamProgress;
    fixed lp_chaosTeamProgress = auto_libSCHO_gf_MMHOTransmissionBeaconsFullyCaptured_lp_chaosTeamProgress;

    // Variable Declarations
    playergroup lv_groupOrder;
    playergroup lv_groupChaos;
    playergroup lv_groupObserver;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_groupOrder = PlayerGroupEmpty();
    lv_groupChaos = PlayerGroupEmpty();
    lv_groupObserver = PlayerGroupEmpty();

    // Implementation
    Wait(1.0, c_timeGame);
    if ((libGame_gv_gameOver == true)) {
        return true;
    }

    TriggerQueueEnter();
    lv_groupOrder = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamOrderIndex_C, false);
    lv_groupChaos = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamChaosIndex_C, false);
    lv_groupObserver = libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer];
    libNtve_gf_AddPlayerGroupToPlayerGroup(lv_groupObserver, lv_groupOrder);
    UserDataResetType("MapVOEvent");
    ConversationDataLineResetPlayers("HoldoutVO", ("Left"));
    ConversationDataLineResetPlayers("HoldoutVO", ("Right"));
    if ((libSCHO_gv_mMHO_NumberOfEventsFired == 1)) {
        UserDataSetInt("MapVOEvent", "Holdout - First Zerg Warning", "Value", 1, 1);
    }
    else {
        UserDataSetInt("MapVOEvent", "Holdout - Subsequent Zerg Warnings", "Value", 1, 1);
    }
    if ((lp_orderTeamProgress > lp_chaosTeamProgress)) {
        UserDataSetInt("MapVOEvent", "Holdout - Zerg Power Not Equal", "Value", 1, 1);
        ConversationDataLineSetPlayers("HoldoutVO", ("Left"), lv_groupOrder);
        ConversationDataLineSetPlayers("HoldoutVO", ("Right"), lv_groupChaos);
    }

    if ((lp_orderTeamProgress < lp_chaosTeamProgress)) {
        UserDataSetInt("MapVOEvent", "Holdout - Zerg Power Not Equal", "Value", 1, 1);
        ConversationDataLineSetPlayers("HoldoutVO", ("Left"), lv_groupChaos);
        ConversationDataLineSetPlayers("HoldoutVO", ("Right"), lv_groupOrder);
    }

    if ((lp_orderTeamProgress == lp_chaosTeamProgress)) {
        UserDataSetInt("MapVOEvent", "Holdout - Zerg Power Equal", "Value", 1, 1);
    }

    ConversationDataRun("HoldoutVO", PlayerGroupAll(), c_conversationSkipNone, false);
    libCore_gf_WaitForConversationToFinish();
    TriggerQueueExit();
    return true;
}

void libSCHO_gf_MMHOUpdateTerranScaling () {
    // Automatic Variable Declarations
    unitgroup auto8529E143_g;
    int auto8529E143_u;
    unit auto8529E143_var;
    unitgroup auto6DDA816B_g;
    int auto6DDA816B_u;
    unit auto6DDA816B_var;
    unitgroup auto17CDE435_g;
    int auto17CDE435_u;
    unit auto17CDE435_var;
    unitgroup auto23E8D062_g;
    int auto23E8D062_u;
    unit auto23E8D062_var;

    // Implementation
    auto8529E143_g = UnitGroup("TerranMarine", c_playerAny, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32))), 0);
    auto8529E143_u = UnitGroupCount(auto8529E143_g, c_unitCountAll);
    for (;; auto8529E143_u -= 1) {
        auto8529E143_var = UnitGroupUnitFromEnd(auto8529E143_g, auto8529E143_u);
        if (auto8529E143_var == null) { break; }
        UnitXPAddXP(auto8529E143_var, null, 1.0);
    }
    auto6DDA816B_g = UnitGroup("TerranHellbat", c_playerAny, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    auto6DDA816B_u = UnitGroupCount(auto6DDA816B_g, c_unitCountAll);
    for (;; auto6DDA816B_u -= 1) {
        auto6DDA816B_var = UnitGroupUnitFromEnd(auto6DDA816B_g, auto6DDA816B_u);
        if (auto6DDA816B_var == null) { break; }
        UnitXPAddXP(auto6DDA816B_var, null, 1.0);
    }
    auto17CDE435_g = UnitGroup("TerranGoliath", c_playerAny, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    auto17CDE435_u = UnitGroupCount(auto17CDE435_g, c_unitCountAll);
    for (;; auto17CDE435_u -= 1) {
        auto17CDE435_var = UnitGroupUnitFromEnd(auto17CDE435_g, auto17CDE435_u);
        if (auto17CDE435_var == null) { break; }
        UnitXPAddXP(auto17CDE435_var, null, 1.0);
    }
    auto23E8D062_g = UnitGroup("TerranRaven", c_playerAny, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    auto23E8D062_u = UnitGroupCount(auto23E8D062_g, c_unitCountAll);
    for (;; auto23E8D062_u -= 1) {
        auto23E8D062_var = UnitGroupUnitFromEnd(auto23E8D062_g, auto23E8D062_u);
        if (auto23E8D062_var == null) { break; }
        UnitXPAddXP(auto23E8D062_var, null, 1.0);
    }
}

void libSCHO_gf_MMHOCalculateZergTotalHP (bool lp_calculateMaximum) {
    // Variable Declarations
    int lv_team;
    int lv_totalZergUnits;

    // Automatic Variable Declarations
    const int auto993CB229_ae = libGame_gv_teamChaosIndex_C;
    const int auto993CB229_ai = 1;
    unitgroup auto021841C3_g;
    int auto021841C3_u;
    unit auto021841C3_var;

    // Variable Initialization

    // Implementation
    TriggerEnable(libSCHO_gt_MMHOZergUnitTakesDamage, true);
    lv_team = libGame_gv_teamOrderIndex_C;
    for ( ; ( (auto993CB229_ai >= 0 && lv_team <= auto993CB229_ae) || (auto993CB229_ai < 0 && lv_team >= auto993CB229_ae) ) ; lv_team += auto993CB229_ai ) {
        libSCHO_gv_mMHO_TotalZergHP[lv_team] = 0.0;
        auto021841C3_g = libSCHO_gv_mMHO_AttackGroups[lv_team][libSCHO_gv_mMHO_WaveTracker];
        auto021841C3_u = UnitGroupCount(auto021841C3_g, c_unitCountAll);
        for (;; auto021841C3_u -= 1) {
            auto021841C3_var = UnitGroupUnitFromEnd(auto021841C3_g, auto021841C3_u);
            if (auto021841C3_var == null) { break; }
            if ((UnitIsAlive(auto021841C3_var) == true) && (UnitGetType(auto021841C3_var) == "ZergUltralisk")) {
                libSCHO_gv_mMHO_TotalZergHP[lv_team] += (UnitGetPropertyFixed(auto021841C3_var, c_unitPropLife, c_unitPropCurrent) * libSCHO_gv_mMHO_UltraliskHealthWeighting);
            }
            else if ((UnitIsAlive(auto021841C3_var) == true) && (UnitGetType(auto021841C3_var) == "ZergGuardian")) {
                libSCHO_gv_mMHO_TotalZergHP[lv_team] += (UnitGetPropertyFixed(auto021841C3_var, c_unitPropLife, c_unitPropCurrent) * libSCHO_gv_mMHO_GuardianHealthWeighting);
            }
        }
    }
    if ((lp_calculateMaximum == true)) {
        UnitSetPropertyFixed(libSCHO_gv_mMHO_OrderProgressUnit, c_unitPropLifeMax, MaxF(libSCHO_gv_mMHO_TotalZergHP[libGame_gv_teamOrderIndex_C], libSCHO_gv_mMHO_TotalZergHP[libGame_gv_teamChaosIndex_C]));
        UnitSetPropertyFixed(libSCHO_gv_mMHO_ChaosProgressUnit, c_unitPropLifeMax, MaxF(libSCHO_gv_mMHO_TotalZergHP[libGame_gv_teamOrderIndex_C], libSCHO_gv_mMHO_TotalZergHP[libGame_gv_teamChaosIndex_C]));
    }

    UnitSetPropertyFixed(libSCHO_gv_mMHO_OrderProgressUnit, c_unitPropLife, libSCHO_gv_mMHO_TotalZergHP[libGame_gv_teamOrderIndex_C]);
    UnitSetPropertyFixed(libSCHO_gv_mMHO_ChaosProgressUnit, c_unitPropLife, libSCHO_gv_mMHO_TotalZergHP[libGame_gv_teamChaosIndex_C]);
    libNtve_gf_SetDialogItemText(libSCHO_gv_mMHOPanel.lv_beaconProgressHPBarLabel[1][1], (FixedToText(UnitGetPropertyFixed(libSCHO_gv_mMHO_OrderProgressUnit, c_unitPropLifePercent, c_unitPropCurrent), 0) + StringExternal("Param/Value/lib_SCHO_3D6BFA79")), PlayerGroupAll());
    libNtve_gf_SetDialogItemText(libSCHO_gv_mMHOPanel.lv_beaconProgressHPBarLabel[2][1], (FixedToText(UnitGetPropertyFixed(libSCHO_gv_mMHO_OrderProgressUnit, c_unitPropLifePercent, c_unitPropCurrent), 0) + StringExternal("Param/Value/lib_SCHO_0329DCD0")), PlayerGroupAll());
    libNtve_gf_SetDialogItemText(libSCHO_gv_mMHOPanel.lv_beaconProgressHPBarLabel[1][2], (FixedToText(UnitGetPropertyFixed(libSCHO_gv_mMHO_ChaosProgressUnit, c_unitPropLifePercent, c_unitPropCurrent), 0) + StringExternal("Param/Value/lib_SCHO_AC9B0BC2")), PlayerGroupAll());
    libNtve_gf_SetDialogItemText(libSCHO_gv_mMHOPanel.lv_beaconProgressHPBarLabel[2][2], (FixedToText(UnitGetPropertyFixed(libSCHO_gv_mMHO_ChaosProgressUnit, c_unitPropLifePercent, c_unitPropCurrent), 0) + StringExternal("Param/Value/lib_SCHO_4284B277")), PlayerGroupAll());
}

void libSCHO_gf_MMHOChangeZergMinimapIconsBasedOnZergHealth (int lp_team, unit lp_unit) {
    // Variable Declarations
    string lv_pingModelForTeam;
    string lv_pingModelForEnemyTeam;
    fixed lv_teamProgress;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    if ((UnitIsAlive(libSCHO_gv_mMHO_ZergIconUnit[lp_team].lv_iconUnit) == false)) {
        PingDestroy(libSCHO_gv_mMHO_AllyZergIcon[lp_team]);
        libSCHO_gv_mMHO_AllyZergIcon[lp_team] = c_invalidPingId;
        PingDestroy(libSCHO_gv_mMHO_EnemyZergIcon[lp_team]);
        libSCHO_gv_mMHO_EnemyZergIcon[lp_team] = c_invalidPingId;
        PingDestroy(libSCHO_gv_mMHO_ObsZergPing[lp_team]);
        libSCHO_gv_mMHO_ObsZergPing[lp_team] = c_invalidPingId;
    }

    lv_teamProgress = libSCHO_gv_mMHO_TeamProgress[lp_team];
    if ((lv_teamProgress == 100.0)) {
        lv_pingModelForTeam = "HoldoutBeaconZergBlueIconC";
        lv_pingModelForEnemyTeam = "HoldoutBeaconZergRedIconC";
    }

    if ((lv_teamProgress < 100.0) && (lv_teamProgress >= 50.0)) {
        lv_pingModelForTeam = "HoldoutBeaconZergBlueIconB";
        lv_pingModelForEnemyTeam = "HoldoutBeaconZergRedIconB";
    }

    if ((lv_teamProgress < 50.0)) {
        lv_pingModelForTeam = "HoldoutBeaconZergBlueIconA";
        lv_pingModelForEnemyTeam = "HoldoutBeaconZergRedIconA";
    }

    if ((lp_team == libGame_gv_teamOrderIndex_C)) {
        libSCHO_gv_mMHO_ObsZergPing[lp_team] = libSCHO_gf_MMHOCreateZergPing(PlayerGroupSingle(libCore_gv_oBSERVER_ObserverUIPlayer), lp_unit, lv_pingModelForTeam);
    }
    else {
        libSCHO_gv_mMHO_ObsZergPing[lp_team] = libSCHO_gf_MMHOCreateZergPing(PlayerGroupSingle(libCore_gv_oBSERVER_ObserverUIPlayer), lp_unit, lv_pingModelForEnemyTeam);
    }
    libSCHO_gv_mMHO_AllyZergIcon[lp_team] = libSCHO_gf_MMHOCreateZergPing(libGame_gv_teams[lp_team].lv_teamPlayerGroup, lp_unit, lv_pingModelForTeam);
    libSCHO_gv_mMHO_EnemyZergIcon[lp_team] = libSCHO_gf_MMHOCreateZergPing(libGame_gv_teams[libGame_gf_EnemyTeam(lp_team)].lv_teamPlayerGroup, lp_unit, lv_pingModelForEnemyTeam);
    libSCHO_gv_mMHO_ZergIconUnit[lp_team].lv_iconUnit = lp_unit;
    UnitSetCustomValue(lp_unit, libCore_gf_CustomValueIndex(libCore_ge_CustomValueIndexes_MercLanerGroupIndex), IntToFixed(libSCHO_gv_mMHO_ZergAICustomUnitValue[lp_team]));
}

void libSCHO_gf_MMHOUpdateZergMinimapIcons (int lp_team) {
    // Variable Declarations
    point lv_testPoint;

    // Automatic Variable Declarations
    unitgroup auto2DA5B050_g;
    int auto2DA5B050_u;
    unit auto2DA5B050_var;

    // Variable Initialization

    // Implementation
    if ((UnitGroupCount(libSCHO_gv_mMHO_AttackGroups[lp_team][libSCHO_gv_mMHO_WaveTracker], c_unitCountAlive) > 0)) {
        auto2DA5B050_g = libSCHO_gv_mMHO_AttackGroups[lp_team][libSCHO_gv_mMHO_WaveTracker];
        auto2DA5B050_u = UnitGroupCount(auto2DA5B050_g, c_unitCountAll);
        for (;; auto2DA5B050_u -= 1) {
            auto2DA5B050_var = UnitGroupUnitFromEnd(auto2DA5B050_g, auto2DA5B050_u);
            if (auto2DA5B050_var == null) { break; }
            if ((UnitIsAlive(auto2DA5B050_var) == true)) {
                libSCHO_gf_MMHOChangeZergMinimapIconsBasedOnZergHealth(lp_team, auto2DA5B050_var);
                break;
            }

        }
    }
    else {
        PingDestroy(libSCHO_gv_mMHO_AllyZergIcon[lp_team]);
        libSCHO_gv_mMHO_AllyZergIcon[lp_team] = c_invalidPingId;
        PingDestroy(libSCHO_gv_mMHO_EnemyZergIcon[lp_team]);
        libSCHO_gv_mMHO_EnemyZergIcon[lp_team] = c_invalidPingId;
        PingDestroy(libSCHO_gv_mMHO_ObsZergPing[lp_team]);
        libSCHO_gv_mMHO_ObsZergPing[lp_team] = c_invalidPingId;
        PathDestroy(libSCHO_gv_mMHO_ZergPaths[lp_team]);
    }
}

trigger auto_libSCHO_gf_MMHOInitializeZergPath_Trigger = null;

void libSCHO_gf_MMHOInitializeZergPath () {
    if (auto_libSCHO_gf_MMHOInitializeZergPath_Trigger == null) {
        auto_libSCHO_gf_MMHOInitializeZergPath_Trigger = TriggerCreate("auto_libSCHO_gf_MMHOInitializeZergPath_TriggerFunc");
    }

    TriggerExecute(auto_libSCHO_gf_MMHOInitializeZergPath_Trigger, false, false);
}

bool auto_libSCHO_gf_MMHOInitializeZergPath_TriggerFunc (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_itTeam;

    // Automatic Variable Declarations
    const int autoBA9DD683_ae = libCore_gv_bALMaxTeams;
    const int autoBA9DD683_ai = 1;

    // Variable Initialization

    // Implementation
    lv_itTeam = 1;
    for ( ; ( (autoBA9DD683_ai >= 0 && lv_itTeam <= autoBA9DD683_ae) || (autoBA9DD683_ai < 0 && lv_itTeam >= autoBA9DD683_ae) ) ; lv_itTeam += autoBA9DD683_ai ) {
        libSCHO_gf_MMHOCreateZergPath(lv_itTeam, true);
    }
    TriggerEnable(libSCHO_gt_MMHOUpdateZergPath, true);
    return true;
}

void libSCHO_gf_MMHOCreateZergPath (int lp_team, bool lp_newPath) {
    // Variable Declarations
    int lv_itWaypoint;
    int lv_currentLane;

    // Automatic Variable Declarations
    int autoCDD13B39_val;

    // Variable Initialization

    // Implementation
    if (((UnitGroupCount(libSCHO_gv_mMHO_AttackGroups[lp_team][libSCHO_gv_mMHO_WaveTracker], c_unitCountAlive) == 0) || (UnitIsAlive(libSCHO_gv_mMHO_ZergIconUnit[lp_team].lv_iconUnit) == false))) {
        return ;
    }

    if ((lp_newPath == false)) {
        if ((libSCHO_gv_mMHO_ZergCurrentPathIndex[lp_team] < libSCHO_gv_mMHO_ZergPathIndexMax[lp_team])) {
            PathSetWayPointIndexStart(libSCHO_gv_mMHO_ZergPaths[lp_team], libSCHO_gv_mMHO_ZergCurrentPathIndex[lp_team]);
        }
        else if ((libSCHO_gv_mMHO_ZergCurrentPathIndex[lp_team] >= libSCHO_gv_mMHO_ZergPathIndexMax[lp_team])) {
            PathDestroy(libSCHO_gv_mMHO_ZergPaths[lp_team]);
            PathCreateForUnit(PlayerGroupAll(), libSCHO_gv_mMHO_ZergIconUnit[lp_team].lv_iconUnit);
            PathSetOwnerPlayerId(PathLastCreated(), libGame_gf_ComputerPlayerInTeam(lp_team));
            libSCHO_gv_mMHO_ZergPaths[lp_team] = PathLastCreated();
            PathSetVisible(libSCHO_gv_mMHO_ZergPaths[lp_team], c_pathLocationMinimap, true);
            PathSetVisible(libSCHO_gv_mMHO_ZergPaths[lp_team], c_pathLocationWorld, false);
            PathSetDestinationUnit(libSCHO_gv_mMHO_ZergPaths[lp_team], libGame_gv_teams[libGame_gf_EnemyTeam(lp_team)].lv_core);
        }
        return ;
    }
    else {
        libSCHO_gv_mMHO_ZergCurrentPathIndex[lp_team] = 1;
        libSCHO_gv_mMHO_ZergPathIndexMax[lp_team] = 1;
        if ((libSCHO_gv_mMHO_ZergPaths[lp_team] != 0)) {
            PathClearWayPoints(libSCHO_gv_mMHO_ZergPaths[lp_team]);
            PathDestroy(libSCHO_gv_mMHO_ZergPaths[lp_team]);
        }

    }
    lv_currentLane = libAIAI_gf_MinionAIGetLaneForMinion(libSCHO_gv_mMHO_ZergIconUnit[lp_team].lv_iconUnit);
    lv_itWaypoint = libAIAI_gf_MinionAIGetNextWaypointIndexForMinion(libSCHO_gv_mMHO_ZergIconUnit[lp_team].lv_iconUnit);
    PathCreateForUnit(PlayerGroupAll(), libSCHO_gv_mMHO_ZergIconUnit[lp_team].lv_iconUnit);
    PathSetOwnerPlayerId(PathLastCreated(), libGame_gf_ComputerPlayerInTeam(lp_team));
    libSCHO_gv_mMHO_ZergPaths[lp_team] = PathLastCreated();
    PathSetVisible(libSCHO_gv_mMHO_ZergPaths[lp_team], c_pathLocationMinimap, true);
    PathSetVisible(libSCHO_gv_mMHO_ZergPaths[lp_team], c_pathLocationWorld, false);
    PathSetDestinationUnit(libSCHO_gv_mMHO_ZergPaths[lp_team], libGame_gv_teams[libGame_gf_EnemyTeam(lp_team)].lv_core);
    autoCDD13B39_val = lp_team;
    if (autoCDD13B39_val == libGame_gv_teamOrderIndex_C) {
        while ((lv_itWaypoint < (libGame_gv_laneData[lv_currentLane].lv_waypointCount - 1))) {
            PathAddWayPoint(libSCHO_gv_mMHO_ZergPaths[lp_team], libGame_gv_laneData[lv_currentLane].lv_waypoints[lv_itWaypoint]);
            lv_itWaypoint += 1;
            libSCHO_gv_mMHO_ZergPathIndexMax[libGame_gv_teamOrderIndex_C] += 1;
        }
    }
    else if (autoCDD13B39_val == libGame_gv_teamChaosIndex_C) {
        while ((lv_itWaypoint > 1)) {
            PathAddWayPoint(libSCHO_gv_mMHO_ZergPaths[lp_team], libGame_gv_laneData[lv_currentLane].lv_waypoints[lv_itWaypoint]);
            lv_itWaypoint -= 1;
            libSCHO_gv_mMHO_ZergPathIndexMax[libGame_gv_teamChaosIndex_C] += 1;
        }
    }
    else {
    }
}

int libSCHO_gf_MMHOCreateZergPing (playergroup lp_playerGroup, unit lp_unit, string lp_zergPingModel) {
    // Automatic Variable Declarations
    // Implementation
    libNtve_gf_CreatePingFacingAngleWithType(lp_playerGroup, lp_zergPingModel, UnitGetPosition(lp_unit), ColorWithAlpha(0.00, 0.00, 0.00, 0.00), 0.0, -135.0, -1, -1);
    PingSetUnit(PingLastCreated(), lp_unit);
    PingSetScale(PingLastCreated(), 0.15);
    return PingLastCreated();
}

void libSCHO_gf_MMHOUIInit (int lp_parentPanel) {
    int init_i;

    // Variable Declarations
    int[8] lv_panels;
    int lv_currentPanelLayer;
    int lv_itTeam;
    int lv_enemyTeam;

    // Automatic Variable Declarations
    const int auto4AF678B4_ae = 2;
    const int auto4AF678B4_ai = 1;
    int auto9E75F3F0_val;

    // Variable Initialization
    for (init_i = 0; init_i <= 7; init_i += 1) {
        lv_panels[init_i] = c_invalidDialogControlId;
    }

    // Implementation
    DialogControlCreateInPanelFromTemplate(lp_parentPanel, c_triggerControlTypePanel, "HoldOut/HoldOutPanel");
    DialogControlSetVisible(DialogControlLastCreated(), PlayerGroupAll(), false);
    lv_currentPanelLayer += 1;
    lv_panels[lv_currentPanelLayer] = DialogControlLastCreated();
    libSCHO_gv_mMHOPanel.lv_mainPanel = DialogControlLastCreated();
    DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypePanel, "HoldOutWarningFrame");
    DialogControlSetVisible(DialogControlLastCreated(), PlayerGroupAll(), false);
    lv_currentPanelLayer += 1;
    lv_panels[lv_currentPanelLayer] = DialogControlLastCreated();
    libSCHO_gv_mMHOPanel.lv_zergWarningFrame = DialogControlLastCreated();
    DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypeLabel, "HoldOutWarningInfoLabel");
    libSCHO_gv_mMHOPanel.lv_zergWarningInfoFrame = DialogControlLastCreated();
    libNtve_gf_SetDialogItemText(DialogControlLastCreated(), StringExternal("Param/Value/lib_SCHO_6639B1F4"), PlayerGroupAll());
    DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypeLabel, "HoldOutWarningTimerLabel");
    libSCHO_gv_mMHOPanel.lv_zergWarningTimerLabel = DialogControlLastCreated();
    lv_currentPanelLayer -= 1;
    lv_itTeam = 1;
    for ( ; ( (auto4AF678B4_ai >= 0 && lv_itTeam <= auto4AF678B4_ae) || (auto4AF678B4_ai < 0 && lv_itTeam >= auto4AF678B4_ae) ) ; lv_itTeam += auto4AF678B4_ai ) {
        lv_enemyTeam = libGame_gf_EnemyTeam(lv_itTeam);
        auto9E75F3F0_val = lv_itTeam;
        if (auto9E75F3F0_val == 1) {
            DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypePanel, "BossDuelLeftFrame");
        }
        else if (auto9E75F3F0_val == 2) {
            DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypePanel, "BossDuelRightFrame");
        }
        else {
        }
        libSCHO_gv_mMHOPanel.lv_beaconProgressFrame[lv_itTeam] = DialogControlLastCreated();
        DialogControlSetVisible(DialogControlLastCreated(), PlayerGroupAll(), false);
        lv_currentPanelLayer += 1;
        lv_panels[lv_currentPanelLayer] = DialogControlLastCreated();
        DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypeImage, "ZergHudRight");
        DialogControlSetVisible(DialogControlLastCreated(), PlayerGroupAll(), false);
        libSCHO_gv_mMHOPanel.lv_zergHudRight[lv_itTeam] = DialogControlLastCreated();
        DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypeImage, "ZergHudLeft");
        DialogControlSetVisible(DialogControlLastCreated(), PlayerGroupAll(), false);
        libSCHO_gv_mMHOPanel.lv_zergHudLeft[lv_itTeam] = DialogControlLastCreated();
        DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypeLabel, "AlliedZergLabel");
        libNtve_gf_SetDialogItemText(DialogControlLastCreated(), StringExternal("Param/Value/lib_SCHO_E540DB8E"), PlayerGroupAll());
        libNtve_gf_SetDialogItemText(DialogControlLastCreated(), StringExternal("Param/Value/lib_SCHO_DB948499"), PlayerGroupSingle(libCore_gv_oBSERVER_ObserverUIPlayer));
        DialogControlSetVisible(DialogControlLastCreated(), PlayerGroupAll(), false);
        libSCHO_gv_mMHOPanel.lv_alliedZergLabel[lv_itTeam] = DialogControlLastCreated();
        DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypeLabel, "EnemyZergLabel");
        libNtve_gf_SetDialogItemText(DialogControlLastCreated(), StringExternal("Param/Value/lib_SCHO_DF7BE75B"), PlayerGroupAll());
        libNtve_gf_SetDialogItemText(DialogControlLastCreated(), StringExternal("Param/Value/lib_SCHO_D5905265"), PlayerGroupSingle(libCore_gv_oBSERVER_ObserverUIPlayer));
        DialogControlSetVisible(DialogControlLastCreated(), PlayerGroupAll(), false);
        libSCHO_gv_mMHOPanel.lv_enemyZergLabel[lv_itTeam] = DialogControlLastCreated();
        DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypeLabel, "BeaconProgressLabel");
        libNtve_gf_SetDialogItemText(DialogControlLastCreated(), StringExternal("Param/Value/lib_SCHO_C04266F1"), PlayerGroupAll());
        libSCHO_gv_mMHOPanel.lv_beaconProgressLabel[lv_itTeam] = DialogControlLastCreated();
        DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypeImage, "BossHudLeft");
        libSCHO_gv_mMHOPanel.lv_eggIconImageLeft[lv_itTeam] = DialogControlLastCreated();
        DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypeImage, "BossHudRight");
        libSCHO_gv_mMHOPanel.lv_eggIconImageRight[lv_itTeam] = DialogControlLastCreated();
        DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypePanel, "HealthBarTopContainerFrame");
        lv_currentPanelLayer += 1;
        lv_panels[lv_currentPanelLayer] = DialogControlLastCreated();
        DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypePanel, "HealthBarTopAnimFrame");
        libSCHO_gv_mMHOPanel.lv_beaconProgressHPBarAnimFrame[lv_itTeam][lv_itTeam] = DialogControlLastCreated();
        lv_currentPanelLayer += 1;
        lv_panels[lv_currentPanelLayer] = DialogControlLastCreated();
        DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypeUnitStatus, "AllyBossHealthBar");
        libSCHO_gv_mMHOPanel.lv_beaconProgressHPBar[lv_itTeam][lv_itTeam] = DialogControlLastCreated();
        lv_currentPanelLayer -= 2;
        DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypePanel, "HealthBarBottomContainerFrame");
        lv_currentPanelLayer += 1;
        lv_panels[lv_currentPanelLayer] = DialogControlLastCreated();
        DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypePanel, "HealthBarBottomAnimFrame");
        libSCHO_gv_mMHOPanel.lv_beaconProgressHPBarAnimFrame[lv_itTeam][lv_enemyTeam] = DialogControlLastCreated();
        lv_currentPanelLayer += 1;
        lv_panels[lv_currentPanelLayer] = DialogControlLastCreated();
        DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypeUnitStatus, "EnemyBossHealthBar");
        libSCHO_gv_mMHOPanel.lv_beaconProgressHPBar[lv_itTeam][lv_enemyTeam] = DialogControlLastCreated();
        lv_currentPanelLayer -= 2;
        DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypeLabel, "LeftBossHealthLabel");
        libSCHO_gv_mMHOPanel.lv_beaconProgressHPBarLabel[lv_itTeam][1] = DialogControlLastCreated();
        DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypeLabel, "RightBossHealthLabel");
        libSCHO_gv_mMHOPanel.lv_beaconProgressHPBarLabel[lv_itTeam][2] = DialogControlLastCreated();
        lv_currentPanelLayer -= 1;
    }
    DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypePanel, "RadarDishModeFrame");
    lv_currentPanelLayer += 1;
    lv_panels[lv_currentPanelLayer] = DialogControlLastCreated();
    libSCHO_gv_mMHOPanel.lv_beaconStatusFrame = DialogControlLastCreated();
    DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypeImage, "HoldOutBeaconTopOff");
    DialogControlSetVisible(DialogControlLastCreated(), PlayerGroupAll(), false);
    libSCHO_gv_mMHOPanel.lv_beaconTopNeutral = DialogControlLastCreated();
    DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypeImage, "HoldOutBeaconTopOrder");
    DialogControlSetVisible(DialogControlLastCreated(), PlayerGroupAll(), false);
    libSCHO_gv_mMHOPanel.lv_beaconTopOrder = DialogControlLastCreated();
    DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypeImage, "HoldOutBeaconTopChaos");
    DialogControlSetVisible(DialogControlLastCreated(), PlayerGroupAll(), false);
    libSCHO_gv_mMHOPanel.lv_beaconTopChaos = DialogControlLastCreated();
    DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypeImage, "HoldOutBeaconBottomOff");
    DialogControlSetVisible(DialogControlLastCreated(), PlayerGroupAll(), false);
    libSCHO_gv_mMHOPanel.lv_beaconBottomNeutral = DialogControlLastCreated();
    DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypeImage, "HoldOutBeaconBottomOrder");
    DialogControlSetVisible(DialogControlLastCreated(), PlayerGroupAll(), false);
    libSCHO_gv_mMHOPanel.lv_beaconBottomOrder = DialogControlLastCreated();
    DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypeImage, "HoldOutBeaconBottomChaos");
    DialogControlSetVisible(DialogControlLastCreated(), PlayerGroupAll(), false);
    libSCHO_gv_mMHOPanel.lv_beaconBottomChaos = DialogControlLastCreated();
    DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypeImage, "HoldOutLink1");
    DialogControlSetVisible(DialogControlLastCreated(), PlayerGroupAll(), false);
    libSCHO_gv_mMHOPanel.lv_lightningLink1 = DialogControlLastCreated();
    DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypeImage, "HoldOutLink2");
    DialogControlSetVisible(DialogControlLastCreated(), PlayerGroupAll(), false);
    libSCHO_gv_mMHOPanel.lv_lightningLink2 = DialogControlLastCreated();
    DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypeImage, "HoldOutLink3");
    DialogControlSetVisible(DialogControlLastCreated(), PlayerGroupAll(), false);
    libSCHO_gv_mMHOPanel.lv_lightningLink3 = DialogControlLastCreated();
    DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypeImage, "HoldOutLink4");
    DialogControlSetVisible(DialogControlLastCreated(), PlayerGroupAll(), false);
    libSCHO_gv_mMHOPanel.lv_lightningLink4 = DialogControlLastCreated();
}

void libSCHO_gf_MMHOUIShowHidePanel (bool lp_showHide) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_mainPanel, libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroupNoNPCPlayers, lp_showHide);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_mainPanel, libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroupNoNPCPlayers, lp_showHide);
    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_mainPanel, libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer], lp_showHide);
}

void libSCHO_gf_MMHOUISetMode (int lp_mode) {
    // Automatic Variable Declarations
    int auto4B1D3F24_val;

    // Implementation
    auto4B1D3F24_val = lp_mode;
    if (auto4B1D3F24_val == libSCHO_ge_MMHOUIModes_Idle) {
        Wait(3.0, c_timeGame);
        libSCHO_gf_MMHOUIShowHidePanel(false);
    }
    else if (auto4B1D3F24_val == libSCHO_ge_MMHOUIModes_ZergWarning) {
        libSCHO_gf_MMHOUIShowHidePanel(true);
        DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconProgressFrame[libGame_gv_teamOrderIndex_C], PlayerGroupAll(), false);
        DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconProgressFrame[libGame_gv_teamChaosIndex_C], PlayerGroupAll(), false);
        DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_zergWarningFrame, PlayerGroupAll(), true);
    }
    else if (auto4B1D3F24_val == libSCHO_ge_MMHOUIModes_ZergAttacking) {
        libSCHO_gf_MMHOUIShowHidePanel(true);
        DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_zergWarningFrame, PlayerGroupAll(), false);
        DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconProgressFrame[libGame_gv_teamOrderIndex_C], PlayerGroupAll(), false);
        DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconProgressFrame[libGame_gv_teamChaosIndex_C], PlayerGroupAll(), false);
    }
    else if (auto4B1D3F24_val == libSCHO_ge_MMHOUIModes_BeaconEvent) {
        libSCHO_gf_MMHOUIShowHidePanel(true);
        DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_zergWarningFrame, PlayerGroupAll(), false);
        DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconProgressFrame[libGame_gv_teamOrderIndex_C], libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamOrderIndex_C, false), true);
        DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconProgressFrame[libGame_gv_teamOrderIndex_C], libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer], true);
        DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconProgressFrame[libGame_gv_teamChaosIndex_C], libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamChaosIndex_C, false), true);
    }
    else {
    }
}

void libSCHO_gf_MMHOUISetZergWarningTime (int lp_progressUnit) {
    // Automatic Variable Declarations
    // Implementation
    libNtve_gf_SetDialogItemText(libSCHO_gv_mMHOPanel.lv_zergWarningTimerLabel, TextTimeFormat(StringToText("<min2/>:<sec2/>"), lp_progressUnit), PlayerGroupAll());
}

void libSCHO_gf_MMHOUISetZergAttackingTime (int lp_progressUnit) {
    // Automatic Variable Declarations
    // Implementation
    libNtve_gf_SetDialogItemText(libSCHO_gv_mMHOPanel.lv_zergAttackingTimerLabel, TextTimeFormat(StringToText("<min2/>:<sec2/>"), lp_progressUnit), PlayerGroupAll());
}

trigger auto_libSCHO_gf_MMHOUICreateProgressUnits_Trigger = null;

void libSCHO_gf_MMHOUICreateProgressUnits () {
    if (auto_libSCHO_gf_MMHOUICreateProgressUnits_Trigger == null) {
        auto_libSCHO_gf_MMHOUICreateProgressUnits_Trigger = TriggerCreate("auto_libSCHO_gf_MMHOUICreateProgressUnits_TriggerFunc");
    }

    TriggerExecute(auto_libSCHO_gf_MMHOUICreateProgressUnits_Trigger, false, false);
}

bool auto_libSCHO_gf_MMHOUICreateProgressUnits_TriggerFunc (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_itTeam;

    // Automatic Variable Declarations
    const int auto0D3A682F_ae = 2;
    const int auto0D3A682F_ai = 1;

    // Variable Initialization

    // Implementation
    if (((libSCHO_gv_mMHO_OrderProgressUnit != null) && (libSCHO_gv_mMHO_ChaosProgressUnit != null))) {
        return true;
    }

    lv_itTeam = 1;
    for ( ; ( (auto0D3A682F_ai >= 0 && lv_itTeam <= auto0D3A682F_ae) || (auto0D3A682F_ai < 0 && lv_itTeam >= auto0D3A682F_ae) ) ; lv_itTeam += auto0D3A682F_ai ) {
        libNtve_gf_CreateUnitsWithDefaultFacing(1, "JungleCampIconUnit", c_unitCreateIgnorePlacement, libGame_gf_ComputerPlayerInTeam(lv_itTeam), Point(0.0, 0.0), null);
        if ((lv_itTeam == 1)) {
            libSCHO_gv_mMHO_OrderProgressUnit = UnitLastCreated();
        }
        else {
            libSCHO_gv_mMHO_ChaosProgressUnit = 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);
    }
    libSCHO_gf_MMHOUISetProgressUnits();
    return true;
}

void libSCHO_gf_MMHOUISetProgressUnits () {
    // Automatic Variable Declarations
    // Implementation
    if (((libSCHO_gv_mMHO_OrderProgressUnit != null) && (libSCHO_gv_mMHO_ChaosProgressUnit != null))) {
        libNtve_gf_SetDialogItemUnit(libSCHO_gv_mMHOPanel.lv_beaconProgressHPBar[1][1], libSCHO_gv_mMHO_OrderProgressUnit, PlayerGroupAll());
        libNtve_gf_SetDialogItemUnit(libSCHO_gv_mMHOPanel.lv_beaconProgressHPBar[1][2], libSCHO_gv_mMHO_ChaosProgressUnit, PlayerGroupAll());
        libNtve_gf_SetDialogItemUnit(libSCHO_gv_mMHOPanel.lv_beaconProgressHPBar[2][1], libSCHO_gv_mMHO_OrderProgressUnit, PlayerGroupAll());
        libNtve_gf_SetDialogItemUnit(libSCHO_gv_mMHOPanel.lv_beaconProgressHPBar[2][2], libSCHO_gv_mMHO_ChaosProgressUnit, PlayerGroupAll());
    }
    else {
        return ;
    }
}

void libSCHO_gf_MMHOUISetZergSwarmKilled (int lp_mode) {
    // Automatic Variable Declarations
    int autoAB1C8089_val;

    // Implementation
    autoAB1C8089_val = lp_mode;
    if (autoAB1C8089_val == libGame_gv_teamOrderIndex_C) {
        if ((libSCHO_gv_mMHO_OrderPlayedAnimation == false)) {
            DialogControlSendAnimationEvent(libSCHO_gv_mMHOPanel.lv_beaconProgressFrame[1], PlayerGroupAll(), "LeftBossDefeated");
            DialogControlSendAnimationEvent(libSCHO_gv_mMHOPanel.lv_beaconProgressFrame[2], PlayerGroupAll(), "LeftBossDefeated");
            libSCHO_gv_mMHO_ChaosPlayedAnimation = true;
        }

    }
    else if (autoAB1C8089_val == libGame_gv_teamChaosIndex_C) {
        if ((libSCHO_gv_mMHO_ChaosPlayedAnimation == false)) {
        }

        DialogControlSendAnimationEvent(libSCHO_gv_mMHOPanel.lv_beaconProgressFrame[1], PlayerGroupAll(), "RightBossDefeated");
        DialogControlSendAnimationEvent(libSCHO_gv_mMHOPanel.lv_beaconProgressFrame[2], PlayerGroupAll(), "RightBossDefeated");
        libSCHO_gv_mMHO_ChaosPlayedAnimation = true;
    }
    else {
    }
}

void libSCHO_gf_MMHOUISetTopBeaconOwner (int lp_team) {
    // Variable Declarations
    int lv_enemyTeam;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    if ((lp_team == 0)) {
        DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_dragonShireMoonShrineEnabledImage[libGame_gv_teamOrderIndex_C], PlayerGroupAll(), false);
        DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_dragonShireMoonShrineEnabledImage[libGame_gv_teamChaosIndex_C], PlayerGroupAll(), false);
    }
    else {
        lv_enemyTeam = (3 - lp_team);
        DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_dragonShireMoonShrineEnabledImage[lp_team], PlayerGroupAll(), true);
        DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_dragonShireMoonShrineEnabledImage[lv_enemyTeam], PlayerGroupAll(), false);
    }
}

void libSCHO_gf_MMHOUISetBottomBeaconOwner (int lp_team) {
    // Variable Declarations
    int lv_enemyTeam;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    if ((lp_team == 0)) {
        DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_dragonShireStarShrineEnabledImage[libGame_gv_teamOrderIndex_C], PlayerGroupAll(), false);
        DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_dragonShireStarShrineEnabledImage[libGame_gv_teamChaosIndex_C], PlayerGroupAll(), false);
    }
    else {
        lv_enemyTeam = (3 - lp_team);
        DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_dragonShireStarShrineEnabledImage[lp_team], PlayerGroupAll(), true);
        DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_dragonShireStarShrineEnabledImage[lv_enemyTeam], PlayerGroupAll(), false);
    }
}

void libSCHO_gf_MMHOUIBeaconStatusMonitor () {
    // Automatic Variable Declarations
    int auto2489A3F1_val;
    int autoD492743C_val;

    // Implementation
    auto2489A3F1_val = UnitGetOwner(libSCHO_gv_mMHO_HiveControlBeacons[1].lv_beaconUnit);
    if (auto2489A3F1_val == libCore_gv_cOMPUTER_Neutral) {
        libSCHO_gf_MMHOUISetTopBeaconOwner(libCore_gv_cOMPUTER_Neutral);
    }
    else if (auto2489A3F1_val == libCore_gv_cOMPUTER_TeamOrder) {
        libSCHO_gf_MMHOUISetTopBeaconOwner(libGame_gv_teamOrderIndex_C);
    }
    else if (auto2489A3F1_val == libCore_gv_cOMPUTER_TeamChaos) {
        libSCHO_gf_MMHOUISetTopBeaconOwner(libGame_gv_teamChaosIndex_C);
    }
    else {
    }
    autoD492743C_val = UnitGetOwner(libSCHO_gv_mMHO_HiveControlBeacons[2].lv_beaconUnit);
    if (autoD492743C_val == libCore_gv_cOMPUTER_Neutral) {
        libSCHO_gf_MMHOUISetBottomBeaconOwner(libCore_gv_cOMPUTER_Neutral);
    }
    else if (autoD492743C_val == libCore_gv_cOMPUTER_TeamOrder) {
        libSCHO_gf_MMHOUISetBottomBeaconOwner(libGame_gv_teamOrderIndex_C);
    }
    else if (autoD492743C_val == libCore_gv_cOMPUTER_TeamChaos) {
        libSCHO_gf_MMHOUISetBottomBeaconOwner(libGame_gv_teamChaosIndex_C);
    }
    else {
    }
}

void libSCHO_gf_MMHOShowHideBeaconMinimapPings (bool lp_showHide) {
    // Automatic Variable Declarations
    // Implementation
    PingSetVisible(libSCHO_gv_mMHO_HiveControlBeacons[1].lv_pingModelOrder, lp_showHide);
    PingSetVisible(libSCHO_gv_mMHO_HiveControlBeacons[1].lv_pingModelChaos, lp_showHide);
    PingSetVisible(libSCHO_gv_mMHO_HiveControlBeacons[2].lv_pingModelChaos, lp_showHide);
    PingSetVisible(libSCHO_gv_mMHO_HiveControlBeacons[2].lv_pingModelOrder, lp_showHide);
}

void libSCHO_gf_MMHOSpawnSpecificAttackWave (region lp_attackRegion, point lp_point, string lp_attackWave) {
    // Variable Declarations
    int lv_itUserData;

    // Automatic Variable Declarations
    const int auto5F9041E4_ae = 3;
    const int auto5F9041E4_ai = 1;

    // Variable Initialization

    // Deprecated
    lv_itUserData = 1;
    for ( ; ( (auto5F9041E4_ai >= 0 && lv_itUserData <= auto5F9041E4_ae) || (auto5F9041E4_ai < 0 && lv_itUserData >= auto5F9041E4_ae) ) ; lv_itUserData += auto5F9041E4_ai ) {
        libNtve_gf_CreateUnitsWithDefaultFacing(UserDataGetInt("AttackWaves", lp_attackWave, "Count", lv_itUserData), UserDataGetGameLink("AttackWaves", lp_attackWave, "Attacking Units", lv_itUserData), 0, libCore_gv_cOMPUTER_Hostile, RegionRandomPoint(lp_attackRegion), null);
    }
}

// Triggers
//--------------------------------------------------------------------------------------------------
// Trigger: #Include HoldOut
//--------------------------------------------------------------------------------------------------
bool libSCHO_gt_IncludeHoldOut_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerExecute(libSCHO_gt_MMHOInitializeMercCampData, true, false);
    TriggerExecute(libSCHO_gt_MMHOInitializePingData, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libSCHO_gt_IncludeHoldOut_Init () {
    libSCHO_gt_IncludeHoldOut = TriggerCreate("libSCHO_gt_IncludeHoldOut_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMHO Initialize Merc Camp Data
//--------------------------------------------------------------------------------------------------
bool libSCHO_gt_MMHOInitializeMercCampData_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_campType;

    // Automatic Variable Declarations
    // Variable Initialization

    // Actions
    if (!runActions) {
        return true;
    }

    lv_campType = (libMapM_ge_JungleCampDefenderTypes_BossCamp1);
    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_campIsSoloable = false;
    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_campIsElite = true;
    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_initialSpawnDelay = libMapM_gv_genericMercBossCampInitialSpawnDelay_C;
    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_respawnTime = 250.0;
    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_numberOfCreeps = 1;
    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_campTypeMinimapLabel = StringExternal("Param/Value/lib_SCHO_DEB65393");
    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_defendersCoweronDeath = false;
    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_creepUnitTypes[1] = "TerranArchangelDefender";
    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_defenderCoweringUnit[1] = false;
    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_xPAwardForCapture = libCore_gv_data_XP_GraveGolemCapture_C;
    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_aIGoalLink = "MercenaryCampGraveGolem";
    libMapM_gv_dataJungleCampMercData[lv_campType].lv_numberOfMinionsSpawned = 0;
    libMapM_gf_DataInitializeScalingDataForDefender(libMapM_ge_JungleCampDefenderTypes_BossCamp1, "TerranArchangelDefenderScaling");
    return true;
}

//--------------------------------------------------------------------------------------------------
void libSCHO_gt_MMHOInitializeMercCampData_Init () {
    libSCHO_gt_MMHOInitializeMercCampData = TriggerCreate("libSCHO_gt_MMHOInitializeMercCampData_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMHO Initialize Ping Data
//--------------------------------------------------------------------------------------------------
bool libSCHO_gt_MMHOInitializePingData_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libUIUI_gf_PingCreateNewPingTarget("ZergHiveControlBeacon", false, StringExternal("Param/Value/lib_SCHO_63EB6567"), StringExternal("Param/Value/lib_SCHO_0A09B086"), StringExternal("Param/Value/lib_SCHO_4B4C4BB6"), SoundLink("UI_Game_Ping_Attack", -1), SoundLink("UI_Game_Ping_Attack", -1));
    libUIUI_gf_PingCreateNewPingTarget("ZergZergling", false, StringExternal("Param/Value/lib_SCHO_AEDBE47A"), StringExternal("Param/Value/lib_SCHO_96C0AB98"), StringExternal("Param/Value/lib_SCHO_EEEE1F04"), SoundLink("UI_Game_Ping_Attack", -1), SoundLink("UI_Game_Ping_Attack", -1));
    libUIUI_gf_PingCreateNewPingTarget("ZergHydralisk", false, StringExternal("Param/Value/lib_SCHO_D661E5B5"), StringExternal("Param/Value/lib_SCHO_883EF8B8"), StringExternal("Param/Value/lib_SCHO_CB673020"), SoundLink("UI_Game_Ping_Attack", -1), SoundLink("UI_Game_Ping_Attack", -1));
    libUIUI_gf_PingCreateNewPingTarget("ZergBaneling", false, StringExternal("Param/Value/lib_SCHO_6D387197"), StringExternal("Param/Value/lib_SCHO_457DBFE2"), StringExternal("Param/Value/lib_SCHO_4E59B8E3"), SoundLink("UI_Game_Ping_Attack", -1), SoundLink("UI_Game_Ping_Attack", -1));
    libUIUI_gf_PingCreateNewPingTarget("ZergUltralisk", false, StringExternal("Param/Value/lib_SCHO_3B6609ED"), StringExternal("Param/Value/lib_SCHO_9B951AEC"), StringExternal("Param/Value/lib_SCHO_B884D856"), SoundLink("UI_Game_Ping_Attack", -1), SoundLink("UI_Game_Ping_Attack", -1));
    libUIUI_gf_PingCreateNewPingTarget("ZergGuardian", false, StringExternal("Param/Value/lib_SCHO_6FDD4E21"), StringExternal("Param/Value/lib_SCHO_10131632"), StringExternal("Param/Value/lib_SCHO_777FEC25"), SoundLink("UI_Game_Ping_Attack", -1), SoundLink("UI_Game_Ping_Attack", -1));
    libUIUI_gf_PingCreateNewPingTarget("TerranArchangelDefender", false, StringExternal("Param/Value/lib_SCHO_1ADEB967"), StringExternal("Param/Value/lib_SCHO_239B828E"), StringExternal("Param/Value/lib_SCHO_93C2EF71"), SoundLink("UI_Game_Ping_Attack", -1), SoundLink("UI_Game_Ping_Attack", -1));
    libUIUI_gf_PingSetHumanAISourceHeroVOForPingTarget(libUIUI_gf_PingLastCreatedPingTarget(), libCore_ge_HeroVOEvents_PingAttackMercCamp, libCore_ge_HeroVOEvents_AIMercCapture);
    libUIUI_gf_PingCreateNewPingTarget("TerranArchangelLaner", false, StringExternal("Param/Value/lib_SCHO_822B4314"), StringExternal("Param/Value/lib_SCHO_0C299E2A"), StringExternal("Param/Value/lib_SCHO_642B339B"), SoundLink("UI_Game_Ping_Attack", -1), SoundLink("UI_Game_Ping_Attack", -1));
    libUIUI_gf_PingSetAllyEnemyTargetHeroVOForPingTarget(libUIUI_gf_PingLastCreatedPingTarget(), libCore_ge_HeroVOEvents_PingAttackHere, libCore_ge_HeroVOEvents_PingAttackHere);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libSCHO_gt_MMHOInitializePingData_Init () {
    libSCHO_gt_MMHOInitializePingData = TriggerCreate("libSCHO_gt_MMHOInitializePingData_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMHO Init
//--------------------------------------------------------------------------------------------------
bool libSCHO_gt_MMHOInit_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((libGame_gf_MapMechanicInitializationMechanicType() == libSCHO_gv_mMSC1MechanicName_C))) {
            return false;
        }
    }

    // Actions
    if (!runActions) {
        return true;
    }

    libSCHO_gv_mMHO_AttackLane = RandomInt(1, 2);
    libSCHO_gf_MMHOInitializeHiveControlCapturePoints();
    libGame_gf_SendMapSpecificAwardInitializeEventwithUserData(null, "Generic Instance");
    libSCHO_gv_mMHO_ZergAICustomUnitValue[libGame_gv_teamOrderIndex_C] = libMapM_gf_RegisterMapMechanicAIUnitCustomValue();
    libSCHO_gv_mMHO_ZergAICustomUnitValue[libGame_gv_teamChaosIndex_C] = libMapM_gf_RegisterMapMechanicAIUnitCustomValue();
    libSCHO_gv_mMHO_ArchangelAICustomUnitValue = libMapM_gf_RegisterMapMechanicAIUnitCustomValue();
    return true;
}

//--------------------------------------------------------------------------------------------------
void libSCHO_gt_MMHOInit_Init () {
    libSCHO_gt_MMHOInit = TriggerCreate("libSCHO_gt_MMHOInit_Func");
    libGame_gf_MapMechanicInitialization(libSCHO_gt_MMHOInit);
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMHO Gate Open
//--------------------------------------------------------------------------------------------------
bool libSCHO_gt_MMHOGateOpen_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_itCamp;

    // Automatic Variable Declarations
    const int auto93719568_ae = 4;
    const int auto93719568_ai = 1;

    // Variable Initialization

    // Actions
    if (!runActions) {
        return true;
    }

    if ((libMapM_gv_mMMapMechanicDisabled == false)) {
        TimerStart(libSCHO_gv_mMHO_AttackEventTimer, libSCHO_gv_mMHO_FirstAttackEventDuration_C, false, c_timeGame);
    }

    TriggerExecute(libSCHO_gt_MMHOUIHandler, true, false);
    libSCHO_gf_MMHORegenGlobeCoolupTime();
    TimerStart(libSCHO_gv_mMHO_ScalingTimer, 60.0, false, c_timeGame);
    TimerStart(libSCHO_gv_mMHO_Elevator.lv_elevatorInitialRaiseTimer, (libMapM_gv_dataJungleCampDefenderData[(libMapM_ge_JungleCampDefenderTypes_BossCamp1)].lv_initialSpawnDelay - libSCHO_gv_mMHO_Elevator_Anim_Headstart_C), false, c_timeGame);
    lv_itCamp = 1;
    for ( ; ( (auto93719568_ai >= 0 && lv_itCamp <= auto93719568_ae) || (auto93719568_ai < 0 && lv_itCamp >= auto93719568_ae) ) ; lv_itCamp += auto93719568_ai ) {
        TimerStart(libSCHO_gv_mMHO_Factory_Timer[lv_itCamp].lv_animationTimer, (libMapM_gv_dataJungleCampDefenderData[libMapM_gv_jungleCreepCamps[lv_itCamp].lv_mapDataCampDefenderType].lv_initialSpawnDelay-libSCHO_gv_mMHO_Factory_Anim_Headstart_C), false, c_timeGame);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libSCHO_gt_MMHOGateOpen_Init () {
    libSCHO_gt_MMHOGateOpen = TriggerCreate("libSCHO_gt_MMHOGateOpen_Func");
    TriggerAddEventTimer(libSCHO_gt_MMHOGateOpen, libGame_gv_openTheGatesTimer);
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMHO Start Warning Timer
//--------------------------------------------------------------------------------------------------
bool libSCHO_gt_MMHOStartWarningTimer_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_index;

    // Automatic Variable Declarations
    const int auto424BF917_ae = libSCHO_gv_mMHO_ControlBeaconMaxCount_C;
    const int auto424BF917_ai = 1;

    // Variable Initialization

    // Actions
    if (!runActions) {
        return true;
    }

    libCore_gf_CreateMinimapPingStorm(PlayerGroupAll(), "StormWarning", libSCHO_gv_mMHO_TopCaptureBeacon, ColorWithAlpha(100.00, 100.00, 0.00, 0.00), 15.0);
    PingSetScale(PingLastCreated(), 0.5);
    libCore_gf_CreateMinimapPingStorm(PlayerGroupAll(), "StormWarning", libSCHO_gv_mMHO_BottomCaptureBeacon, ColorWithAlpha(100.00, 100.00, 0.00, 0.00), 15.0);
    PingSetScale(PingLastCreated(), 0.5);
    SoundPlayForPlayer(SoundLink("UI_Game_Ping_BraxisHoldout_BeaconsEnergizing", -1), c_maxPlayers, PlayerGroupAll(), 100.0, 0.0);
    libSond_gf_SoundtrackApplyNewDefaultSoundtrackForPlayerGroup("MX_BraxisHoldout_BeaconsActivating", libCore_gv_allHeroPlayersPlusObserver);
    TimerStart(libSCHO_gv_mMHO_AttackEventWarningTimer, libSCHO_gv_mMHO_AttackEventWarningDuration_C, false, c_timeGame);
    libAIAI_gf_AITeamDelegateSetPeriodicMapValueAction(libAIAI_ge_AITeamDelegateMapNonEventMapValueOperations_Decrease);
    if ((libSCHO_gv_mMHO_AttackLane == 1)) {
        UnitBehaviorAddPlayer(libSCHO_gv_mMHO_HiveCages[2].lv_south, "HoldingPenControllerBR", libGame_gv_teamChaosIndex_C, 1);
        UnitBehaviorAddPlayer(libSCHO_gv_mMHO_HiveCages[1].lv_north, "HoldingPenControllerTL", libGame_gv_teamOrderIndex_C, 1);
    }
    else {
        UnitBehaviorAddPlayer(libSCHO_gv_mMHO_HiveCages[1].lv_south, "HoldingPenControllerBL", libGame_gv_teamOrderIndex_C, 1);
        UnitBehaviorAddPlayer(libSCHO_gv_mMHO_HiveCages[2].lv_north, "HoldingPenControllerTR", libGame_gv_teamChaosIndex_C, 1);
    }
    libSCHO_gv_mMHO_AttackLaneHPMiniMapController = libSCHO_gv_mMHO_AttackLane;
    libSCHO_gv_mMHO_AttackLane = (3 - libSCHO_gv_mMHO_AttackLane);
    libSCHO_gv_mMHO_NumberOfEventsFired += 1;
    libSCHO_gv_zergDropPodDropsRemaining[1] = libSCHO_gv_zergDropPodMaximumDrops_C;
    libSCHO_gv_zergDropPodDropsRemaining[2] = libSCHO_gv_zergDropPodMaximumDrops_C;
    libSCHO_gf_MMHOTransmissionBeaconsActivating();
    lv_index = 1;
    for ( ; ( (auto424BF917_ai >= 0 && lv_index <= auto424BF917_ae) || (auto424BF917_ai < 0 && lv_index >= auto424BF917_ae) ) ; lv_index += auto424BF917_ai ) {
        AddUnitOfInterest(libSCHO_gv_mMHO_HiveControlBeacons[lv_index].lv_beaconUnit, libSCHO_gv_mMHO_CapturePointRadius_C, libSCHO_gv_mMHO_AttackEventWarningDuration_C, "Beacon", libNtve_ge_GoalTeam_Both, libSCHO_gv_mMHO_HiveControlBeacons[lv_index].lv_controlBeaconIndex);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libSCHO_gt_MMHOStartWarningTimer_Init () {
    libSCHO_gt_MMHOStartWarningTimer = TriggerCreate("libSCHO_gt_MMHOStartWarningTimer_Func");
    TriggerAddEventTimer(libSCHO_gt_MMHOStartWarningTimer, libSCHO_gv_mMHO_AttackEventTimer);
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMHO Warning Timer Expires
//--------------------------------------------------------------------------------------------------
bool libSCHO_gt_MMHOWarningTimerExpires_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libAIAI_gf_AITeamDelegateActivateDeactivateMapEvent(libAIAI_ge_AITeamDelegateActivateDeactivateMapToken_Activate);
    libSCHO_gf_MMHOTransmissionBeaconsActive();
    libSCHO_gf_MMHOTurnOnHiveControlBeacons();
    libSCHO_gf_MMHOHiveBeaconSpawnAnnouncement();
    TriggerExecute(libSCHO_gt_MMHOHiveControlBeaconMonitor, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libSCHO_gt_MMHOWarningTimerExpires_Init () {
    libSCHO_gt_MMHOWarningTimerExpires = TriggerCreate("libSCHO_gt_MMHOWarningTimerExpires_Func");
    TriggerAddEventTimer(libSCHO_gt_MMHOWarningTimerExpires, libSCHO_gv_mMHO_AttackEventWarningTimer);
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMHO Spawn Attack Waves
//--------------------------------------------------------------------------------------------------
bool libSCHO_gt_MMHOSpawnAttackWaves_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libSCHO_gv_mMHO_WaveTracker += 1;
    libSCHO_gf_MMHOSetupZergAttackWave();
    return true;
}

//--------------------------------------------------------------------------------------------------
void libSCHO_gt_MMHOSpawnAttackWaves_Init () {
    libSCHO_gt_MMHOSpawnAttackWaves = TriggerCreate("libSCHO_gt_MMHOSpawnAttackWaves_Func");
    TriggerAddEventTimer(libSCHO_gt_MMHOSpawnAttackWaves, libSCHO_gv_mMHO_AttackWaveTimer);
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMHO Hive Control Beacon Changes Owner
//--------------------------------------------------------------------------------------------------
bool libSCHO_gt_MMHOHiveControlBeaconChangesOwner_Func (bool testConds, bool runActions) {
    // Variable Declarations
    bool lv_bothCapturedByOrder;
    bool lv_bothCapturedByChaos;
    int lv_index;
    int lv_oppositeIndex;
    int lv_itIndex;
    bool lv_capturePointCapturedWasZergBeacon;
    int lv_beaconOwner;

    // Automatic Variable Declarations
    const int auto63C193D0_ae = libSCHO_gv_mMHO_ControlBeaconMaxCount_C;
    const int auto63C193D0_ai = 1;
    int auto31BA37A3_val;
    int autoB98F8E0A_val;

    // Variable Initialization

    // Actions
    if (!runActions) {
        return true;
    }

    if (((libSCHO_gv_mMHO_TeamProgress[libGame_gv_teamOrderIndex_C] >= 100.0) || (libSCHO_gv_mMHO_TeamProgress[libGame_gv_teamChaosIndex_C] >= 100.0))) {
    }

    libNtve_gf_SetDialogItemImage(libSCHO_gv_mMHOPanel.lv_beaconTopNeutral, "Assets\\Textures\\storm_ui_hud_minimap_holdout_beacon_top_off.dds", PlayerGroupAll());
    libNtve_gf_SetDialogItemImage(libSCHO_gv_mMHOPanel.lv_beaconTopOrder, "Assets\\Textures\\storm_ui_hud_minimap_holdout_beacon_top_off.dds", PlayerGroupAll());
    libNtve_gf_SetDialogItemImage(libSCHO_gv_mMHOPanel.lv_beaconTopChaos, "Assets\\Textures\\storm_ui_hud_minimap_holdout_beacon_top_off.dds", PlayerGroupAll());
    libNtve_gf_SetDialogItemImage(libSCHO_gv_mMHOPanel.lv_beaconBottomNeutral, "Assets\\Textures\\storm_ui_hud_minimap_holdout_beacon_bottom_off.dds", PlayerGroupAll());
    libNtve_gf_SetDialogItemImage(libSCHO_gv_mMHOPanel.lv_beaconBottomOrder, "Assets\\Textures\\storm_ui_hud_minimap_holdout_beacon_bottom_off.dds", PlayerGroupAll());
    libNtve_gf_SetDialogItemImage(libSCHO_gv_mMHOPanel.lv_beaconBottomChaos, "Assets\\Textures\\storm_ui_hud_minimap_holdout_beacon_bottom_off.dds", PlayerGroupAll());
    lv_index = 1;
    for ( ; ( (auto63C193D0_ai >= 0 && lv_index <= auto63C193D0_ae) || (auto63C193D0_ai < 0 && lv_index >= auto63C193D0_ae) ) ; lv_index += auto63C193D0_ai ) {
        if ((libSCHO_gv_mMHO_HiveControlBeacons[lv_index].lv_controlBeaconIndex == libGame_gf_CapturePointChangesOwnerCapturePointIndex())) {
            lv_beaconOwner = libSCHO_gf_MMHOGetHiveControlBeaconOwners();
            lv_capturePointCapturedWasZergBeacon = true;
            auto31BA37A3_val = libGame_gf_CapturePointChangesOwnerOwner();
            if (auto31BA37A3_val == libCore_gv_cOMPUTER_TeamOrder) {
                libSCHO_gf_MMHOControlSlabAnimationOwnershipChange(libGame_gv_teamOrderIndex_C, lv_index);
                libSCHO_gf_MMHOSetSwitchAnimationOwnershipChanges(libGame_gv_teamOrderIndex_C, lv_index);
                libCore_gf_CreateMinimapPingStorm(PlayerGroupAll(), "StormAlert", UnitGetPosition(libSCHO_gv_mMHO_HiveControlBeacons[lv_index].lv_beaconUnit), ColorWithAlpha(100.00, 100.00, 0.00, 0.00), 5.0);
                SoundPlayForPlayer(SoundLink("UI_Game_Ping_Reminder2", -1), c_maxPlayers, PlayerGroupAll(), 75.0, 0.0);
                if ((libSCHO_gv_mMHO_HiveControlBeacons[lv_index].lv_controlBeaconIndex == libSCHO_gv_mMHO_HiveControlBeacons[1].lv_controlBeaconIndex)) {
                    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconTopNeutral, PlayerGroupAll(), false);
                    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconTopOrder, PlayerGroupAll(), true);
                    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconTopChaos, PlayerGroupAll(), false);
                }
                else {
                    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconBottomNeutral, PlayerGroupAll(), false);
                    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconBottomOrder, PlayerGroupAll(), true);
                    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconBottomChaos, PlayerGroupAll(), false);
                }
                if ((lv_beaconOwner == libCore_gv_cOMPUTER_Neutral)) {
                    SoundPlayForPlayer(SoundLink("Event_BraxisHoldout_BeaconCaptured_Ally", -1), c_maxPlayers, PlayerGroupSingle(libCore_gv_oBSERVER_ObserverUIPlayer), 100.0, 0.0);
                    SoundPlayForPlayer(SoundLink("Event_BraxisHoldout_BeaconCaptured_Ally", -1), c_maxPlayers, libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamOrderIndex_C, false), 100.0, 0.0);
                    SoundPlayForPlayer(SoundLink("Event_BraxisHoldout_BeaconCaptured_Enemy", -1), c_maxPlayers, libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamChaosIndex_C, false), 100.0, 0.0);
                }

            }
            else if (auto31BA37A3_val == libCore_gv_cOMPUTER_TeamChaos) {
                libSCHO_gf_MMHOControlSlabAnimationOwnershipChange(libGame_gv_teamChaosIndex_C, lv_index);
                libSCHO_gf_MMHOSetSwitchAnimationOwnershipChanges(libGame_gv_teamChaosIndex_C, lv_index);
                libCore_gf_CreateMinimapPingStorm(PlayerGroupAll(), "StormAlert", UnitGetPosition(libSCHO_gv_mMHO_HiveControlBeacons[lv_index].lv_beaconUnit), ColorWithAlpha(100.00, 100.00, 0.00, 0.00), 5.0);
                SoundPlayForPlayer(SoundLink("UI_Game_Ping_Reminder2", -1), c_maxPlayers, PlayerGroupAll(), 75.0, 0.0);
                if ((libSCHO_gv_mMHO_HiveControlBeacons[lv_index].lv_controlBeaconIndex == libSCHO_gv_mMHO_HiveControlBeacons[1].lv_controlBeaconIndex)) {
                    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconTopNeutral, PlayerGroupAll(), false);
                    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconTopOrder, PlayerGroupAll(), false);
                    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconTopChaos, PlayerGroupAll(), true);
                }
                else {
                    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconBottomNeutral, PlayerGroupAll(), false);
                    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconBottomOrder, PlayerGroupAll(), false);
                    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconBottomChaos, PlayerGroupAll(), true);
                }
                if ((lv_beaconOwner == libCore_gv_cOMPUTER_Neutral)) {
                    SoundPlayForPlayer(SoundLink("Event_BraxisHoldout_BeaconCaptured_Ally", -1), c_maxPlayers, libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamChaosIndex_C, false), 100.0, 0.0);
                    SoundPlayForPlayer(SoundLink("Event_BraxisHoldout_BeaconCaptured_Enemy", -1), c_maxPlayers, PlayerGroupSingle(libCore_gv_oBSERVER_ObserverUIPlayer), 100.0, 0.0);
                    SoundPlayForPlayer(SoundLink("Event_BraxisHoldout_BeaconCaptured_Enemy", -1), c_maxPlayers, libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamOrderIndex_C, false), 100.0, 0.0);
                }

            }
            else if (auto31BA37A3_val == libCore_gv_cOMPUTER_Neutral) {
                libSCHO_gf_MMHOControlSlabAnimationOwnershipChange(libCore_gv_cOMPUTER_Neutral, lv_index);
                libSCHO_gf_MMHOSetSwitchAnimationOwnershipChanges(libCore_gv_cOMPUTER_Neutral, lv_index);
                UnitBehaviorRemove(libSCHO_gv_beaconUnitTop, "BeaconRadarWaveControllerTR", 1);
                UnitBehaviorRemove(libSCHO_gv_beaconUnitBottom, "BeaconRadarWaveControllerBR", 1);
                UnitBehaviorRemove(libSCHO_gv_beaconUnitBottom, "BeaconRadarWaveControllerBL", 1);
                UnitBehaviorRemove(libSCHO_gv_beaconUnitTop, "BeaconRadarWaveControllerTL", 1);
                UnitBehaviorRemove(libSCHO_gv_mMHO_HiveCages[2].lv_south, "HoldingPenControllerActiveBR", 1);
                UnitBehaviorRemove(libSCHO_gv_mMHO_HiveCages[2].lv_north, "HoldingPenControllerActiveTR", 1);
                UnitBehaviorRemove(libSCHO_gv_mMHO_HiveCages[1].lv_north, "HoldingPenControllerActiveTL", 1);
                UnitBehaviorRemove(libSCHO_gv_mMHO_HiveCages[1].lv_south, "HoldingPenControllerActiveBL", 1);
                if ((libSCHO_gv_mMHO_HiveControlBeacons[lv_index].lv_controlBeaconIndex == libSCHO_gv_mMHO_HiveControlBeacons[1].lv_controlBeaconIndex)) {
                    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconTopNeutral, PlayerGroupAll(), true);
                    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconTopOrder, PlayerGroupAll(), false);
                    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconTopChaos, PlayerGroupAll(), false);
                }
                else {
                    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconBottomNeutral, PlayerGroupAll(), true);
                    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconBottomOrder, PlayerGroupAll(), false);
                    DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconBottomChaos, PlayerGroupAll(), false);
                }
            }
            else {
            }
            libSCHO_gf_MMHOHiveControlBeaconDoodadController(lv_index);
        }

    }
    if ((lv_capturePointCapturedWasZergBeacon == false)) {
        return true;
    }

    if ((UnitGetOwner(libSCHO_gv_mMHO_BeaconAntennae.lv_north) == lv_beaconOwner) && (UnitGetOwner(libSCHO_gv_mMHO_BeaconAntennae.lv_north) != libCore_gv_cOMPUTER_Neutral)) {
        return true;
    }

    autoB98F8E0A_val = lv_beaconOwner;
    if (autoB98F8E0A_val == libCore_gv_cOMPUTER_Neutral) {
        libNtve_gf_SendActorMessageToUnit(libSCHO_gv_mMHO_HiveCages[libGame_gv_teamOrderIndex_C].lv_south, "Signal BothBeaconsNoLongerCaptured");
        libNtve_gf_SendActorMessageToUnit(libSCHO_gv_mMHO_HiveCages[libGame_gv_teamChaosIndex_C].lv_south, "Signal BothBeaconsNoLongerCaptured");
        ActorSend(ActorFromDoodad(libSCHO_gv_mMHO_TopCaptureSlab), "Signal BothBeaconsNoLongerCaptured");
        ActorSend(ActorFromDoodad(libSCHO_gv_mMHO_BottomCaptureSlab), "Signal BothBeaconsNoLongerCaptured");
        libSCHO_gf_MMHOSetSwitchAnimationBothBeaconsNoLongerCaptured();
        libSCHO_gf_MMHOTurnCaptureCablesOnOffForTeam(false, 0);
        libSCHO_gf_MMHOBothBeaconsNoLongerCapturedBeams();
        libSCHO_gf_MMHOClearAlarmLights();
        DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_lightningLink1, PlayerGroupAll(), false);
        DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_lightningLink2, PlayerGroupAll(), false);
        DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_lightningLink3, PlayerGroupAll(), false);
        DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_lightningLink4, PlayerGroupAll(), false);
        if ((UnitGetOwner(libSCHO_gv_mMHO_HiveControlBeacons[1].lv_beaconUnit) == libCore_gv_cOMPUTER_TeamOrder)) {
            DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconTopNeutral, PlayerGroupAll(), false);
            DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconTopOrder, PlayerGroupAll(), true);
            DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconTopChaos, PlayerGroupAll(), false);
        }
        else if ((UnitGetOwner(libSCHO_gv_mMHO_HiveControlBeacons[2].lv_beaconUnit) == libCore_gv_cOMPUTER_TeamOrder)) {
            DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconBottomNeutral, PlayerGroupAll(), false);
            DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconBottomOrder, PlayerGroupAll(), true);
            DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconBottomChaos, PlayerGroupAll(), false);
        }
        else if ((UnitGetOwner(libSCHO_gv_mMHO_HiveControlBeacons[1].lv_beaconUnit) == libCore_gv_cOMPUTER_TeamChaos)) {
            DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconTopNeutral, PlayerGroupAll(), false);
            DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconTopOrder, PlayerGroupAll(), false);
            DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconTopChaos, PlayerGroupAll(), true);
        }
        else if ((UnitGetOwner(libSCHO_gv_mMHO_HiveControlBeacons[2].lv_beaconUnit) == libCore_gv_cOMPUTER_TeamChaos)) {
            DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconBottomNeutral, PlayerGroupAll(), false);
            DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconBottomOrder, PlayerGroupAll(), false);
            DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_beaconBottomChaos, PlayerGroupAll(), true);
        }
    }
    else if (autoB98F8E0A_val == libCore_gv_cOMPUTER_TeamOrder) {
        libNtve_gf_SendActorMessageToUnit(libSCHO_gv_mMHO_HiveCages[libGame_gv_teamChaosIndex_C].lv_south, "Signal BothBeaconsCaptured");
        ActorSend(ActorFromDoodad(libSCHO_gv_mMHO_TopCaptureSlab), "Signal BothBeaconsCaptured");
        ActorSend(ActorFromDoodad(libSCHO_gv_mMHO_BottomCaptureSlab), "Signal BothBeaconsCaptured");
        libSCHO_gf_MMHOTurnCaptureCablesOnOffForTeam(true, libGame_gv_teamOrderIndex_C);
        libSCHO_gf_MMHOSetSwitchAnimationBothBeaconsCaptured(libGame_gv_teamOrderIndex_C);
        libSCHO_gf_MMHOBothBeaconsCapturedBeams(libGame_gv_teamOrderIndex_C);
        libSCHO_gf_MMHOTurnOnAlarmLightsForTeam(libGame_gv_teamOrderIndex_C);
        if ((libSCHO_gv_mMHO_AttackLaneHPMiniMapController == 1)) {
            UnitBehaviorAddPlayer(libSCHO_gv_beaconUnitTop, "BeaconRadarWaveControllerTL", libGame_gv_teamOrderIndex_C, 1);
            UnitBehaviorAddPlayer(libSCHO_gv_mMHO_HiveCages[1].lv_north, "HoldingPenControllerActiveTL", libGame_gv_teamOrderIndex_C, 1);
            UnitBehaviorRemove(libSCHO_gv_beaconUnitBottom, "BeaconRadarWaveControllerBR", 1);
            UnitBehaviorRemove(libSCHO_gv_mMHO_HiveCages[2].lv_south, "HoldingPenControllerActiveBR", 1);
        }
        else {
            UnitBehaviorAddPlayer(libSCHO_gv_beaconUnitBottom, "BeaconRadarWaveControllerBL", libGame_gv_teamOrderIndex_C, 1);
            UnitBehaviorAddPlayer(libSCHO_gv_mMHO_HiveCages[1].lv_south, "HoldingPenControllerActiveBL", libGame_gv_teamOrderIndex_C, 1);
            UnitBehaviorRemove(libSCHO_gv_beaconUnitTop, "BeaconRadarWaveControllerTR", 1);
            UnitBehaviorRemove(libSCHO_gv_mMHO_HiveCages[2].lv_north, "HoldingPenControllerActiveTR", 1);
        }
        lv_bothCapturedByOrder = true;
    }
    else if (autoB98F8E0A_val == libCore_gv_cOMPUTER_TeamChaos) {
        libNtve_gf_SendActorMessageToUnit(libSCHO_gv_mMHO_HiveCages[libGame_gv_teamOrderIndex_C].lv_south, "Signal BothBeaconsCaptured");
        ActorSend(ActorFromDoodad(libSCHO_gv_mMHO_TopCaptureSlab), "Signal BothBeaconsCaptured");
        ActorSend(ActorFromDoodad(libSCHO_gv_mMHO_BottomCaptureSlab), "Signal BothBeaconsCaptured");
        libSCHO_gf_MMHOTurnCaptureCablesOnOffForTeam(true, libGame_gv_teamChaosIndex_C);
        libSCHO_gf_MMHOSetSwitchAnimationBothBeaconsCaptured(libGame_gv_teamChaosIndex_C);
        libSCHO_gf_MMHOBothBeaconsCapturedBeams(libGame_gv_teamChaosIndex_C);
        libSCHO_gf_MMHOTurnOnAlarmLightsForTeam(libGame_gv_teamChaosIndex_C);
        if ((libSCHO_gv_mMHO_AttackLaneHPMiniMapController == 1)) {
            UnitBehaviorAddPlayer(libSCHO_gv_beaconUnitBottom, "BeaconRadarWaveControllerBR", libGame_gv_teamChaosIndex_C, 1);
            UnitBehaviorAddPlayer(libSCHO_gv_mMHO_HiveCages[2].lv_south, "HoldingPenControllerActiveBR", libGame_gv_teamChaosIndex_C, 1);
            UnitBehaviorRemove(libSCHO_gv_beaconUnitTop, "BeaconRadarWaveControllerTL", 1);
            UnitBehaviorRemove(libSCHO_gv_mMHO_HiveCages[1].lv_north, "HoldingPenControllerActiveTL", 1);
        }
        else {
            UnitBehaviorAddPlayer(libSCHO_gv_beaconUnitTop, "BeaconRadarWaveControllerTR", libGame_gv_teamChaosIndex_C, 1);
            UnitBehaviorAddPlayer(libSCHO_gv_mMHO_HiveCages[2].lv_north, "HoldingPenControllerActiveTR", libGame_gv_teamChaosIndex_C, 1);
            UnitBehaviorRemove(libSCHO_gv_beaconUnitBottom, "BeaconRadarWaveControllerBL", 1);
            UnitBehaviorRemove(libSCHO_gv_mMHO_HiveCages[1].lv_south, "HoldingPenControllerActiveBL", 1);
        }
        lv_bothCapturedByChaos = true;
    }
    else {
    }
    if (((lv_bothCapturedByOrder == true) || (lv_bothCapturedByChaos == true))) {
        if ((lv_bothCapturedByOrder == true)) {
            DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_lightningLink1, libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroupNoNPCPlayers, true);
            DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_lightningLink2, libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroupNoNPCPlayers, true);
            DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_lightningLink1, PlayerGroupSingle(libCore_gv_oBSERVER_ObserverUIPlayer), true);
            DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_lightningLink2, PlayerGroupSingle(libCore_gv_oBSERVER_ObserverUIPlayer), true);
            DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_lightningLink3, libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroupNoNPCPlayers, true);
            DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_lightningLink4, libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroupNoNPCPlayers, true);
            Wait(0.0625, c_timeGame);
            libNtve_gf_SetDialogItemImage(libSCHO_gv_mMHOPanel.lv_beaconTopOrder, "Assets\\Textures\\storm_ui_hud_minimap_holdout_beacon_top_linked_blue.dds", PlayerGroupAll());
            libNtve_gf_SetDialogItemImage(libSCHO_gv_mMHOPanel.lv_beaconBottomOrder, "Assets\\Textures\\storm_ui_hud_minimap_holdout_beacon_bottom_linked_blue.dds", PlayerGroupAll());
        }
        else {
            DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_lightningLink1, libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroupNoNPCPlayers, true);
            DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_lightningLink2, libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_teamPlayerGroupNoNPCPlayers, true);
            DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_lightningLink3, libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroupNoNPCPlayers, true);
            DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_lightningLink4, libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_teamPlayerGroupNoNPCPlayers, true);
            DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_lightningLink3, PlayerGroupSingle(libCore_gv_oBSERVER_ObserverUIPlayer), true);
            DialogControlSetVisible(libSCHO_gv_mMHOPanel.lv_lightningLink4, PlayerGroupSingle(libCore_gv_oBSERVER_ObserverUIPlayer), true);
            Wait(0.0625, c_timeGame);
            libNtve_gf_SetDialogItemImage(libSCHO_gv_mMHOPanel.lv_beaconTopChaos, "Assets\\Textures\\storm_ui_hud_minimap_holdout_beacon_top_linked_red.dds", PlayerGroupAll());
            libNtve_gf_SetDialogItemImage(libSCHO_gv_mMHOPanel.lv_beaconBottomChaos, "Assets\\Textures\\storm_ui_hud_minimap_holdout_beacon_bottom_linked_red.dds", PlayerGroupAll());
        }
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libSCHO_gt_MMHOHiveControlBeaconChangesOwner_Init () {
    libSCHO_gt_MMHOHiveControlBeaconChangesOwner = TriggerCreate("libSCHO_gt_MMHOHiveControlBeaconChangesOwner_Func");
    libGame_gf_CapturePointChangesOwner(libSCHO_gt_MMHOHiveControlBeaconChangesOwner);
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMHO Hive Control Beacon Monitor
//--------------------------------------------------------------------------------------------------
bool libSCHO_gt_MMHOHiveControlBeaconMonitor_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_beaconOwner;

    // Automatic Variable Declarations
    int autoD5BD3175_val;

    // Variable Initialization

    // Actions
    if (!runActions) {
        return true;
    }

    while (true) {
        lv_beaconOwner = libSCHO_gf_MMHOGetHiveControlBeaconOwners();
        autoD5BD3175_val = lv_beaconOwner;
        if (autoD5BD3175_val == libCore_gv_cOMPUTER_Neutral) {
            libSCHO_gf_MMHOSetCableAnimationOwership(libCore_gv_cOMPUTER_Neutral);
            DialogControlSendAnimationEvent(libSCHO_gv_mMHOPanel.lv_beaconProgressFrame[1], PlayerGroupAll(), "TopBarPulseStop");
            DialogControlSendAnimationEvent(libSCHO_gv_mMHOPanel.lv_beaconProgressFrame[2], PlayerGroupAll(), "TopBarPulseStop");
            DialogControlSendAnimationEvent(libSCHO_gv_mMHOPanel.lv_beaconProgressFrame[1], PlayerGroupAll(), "BottomBarPulseStop");
            DialogControlSendAnimationEvent(libSCHO_gv_mMHOPanel.lv_beaconProgressFrame[2], PlayerGroupAll(), "BottomBarPulseStop");
        }
        else if (autoD5BD3175_val == libCore_gv_cOMPUTER_TeamOrder) {
            if ((libSCHO_gv_mMHO_TeamProgress[libGame_gv_teamOrderIndex_C] < 100.0)) {
                libSCHO_gf_MMHOSetCableAnimationOwership(libGame_gv_teamOrderIndex_C);
                libSCHO_gf_MMHOControlSlabAnimationsProgress(libGame_gv_teamOrderIndex_C);
                libSCHO_gv_mMHO_TeamProgress[libGame_gv_teamOrderIndex_C] += libSCHO_gv_mMHO_ControlBeaconProgressIncrement_C;
                libAIAI_gf_AITeamDelegateAdjustMapEventProgressforTeam(TruncI(libSCHO_gv_mMHO_ControlBeaconProgressIncrement_C), libGame_gv_teamOrderIndex_C);
                if ((libSCHO_gv_mMHO_TeamProgress[libGame_gv_teamOrderIndex_C] > 100.0)) {
                    libSCHO_gv_mMHO_TeamProgress[libGame_gv_teamOrderIndex_C] = 100.0;
                }

                UnitSetPropertyFixed(libSCHO_gv_mMHO_OrderProgressUnit, c_unitPropLife, libSCHO_gv_mMHO_TeamProgress[libGame_gv_teamOrderIndex_C]);
                libNtve_gf_SetDialogItemText(libSCHO_gv_mMHOPanel.lv_beaconProgressHPBarLabel[1][1], (FixedToText(libSCHO_gv_mMHO_TeamProgress[libGame_gv_teamOrderIndex_C], 0) + StringExternal("Param/Value/lib_SCHO_8681B02F")), PlayerGroupAll());
                libNtve_gf_SetDialogItemText(libSCHO_gv_mMHOPanel.lv_beaconProgressHPBarLabel[2][1], (FixedToText(libSCHO_gv_mMHO_TeamProgress[libGame_gv_teamOrderIndex_C], 0) + StringExternal("Param/Value/lib_SCHO_6033F3F5")), PlayerGroupAll());
                DialogControlSendAnimationEvent(libSCHO_gv_mMHOPanel.lv_beaconProgressFrame[1], PlayerGroupAll(), "TopBarPulse");
                DialogControlSendAnimationEvent(libSCHO_gv_mMHOPanel.lv_beaconProgressFrame[2], PlayerGroupAll(), "BottomBarPulse");
                libSCHO_gf_MMHOPeriodicallySpawnZergUnits(libGame_gv_teamOrderIndex_C);
            }
            else {
                libSCHO_gv_mMHO_TeamProgress[libGame_gv_teamOrderIndex_C] = 100.0;
            }
        }
        else if (autoD5BD3175_val == libCore_gv_cOMPUTER_TeamChaos) {
            if ((libSCHO_gv_mMHO_TeamProgress[libGame_gv_teamChaosIndex_C] < 100.0)) {
                libSCHO_gf_MMHOSetCableAnimationOwership(libGame_gv_teamChaosIndex_C);
                libSCHO_gf_MMHOControlSlabAnimationsProgress(libGame_gv_teamChaosIndex_C);
                libSCHO_gv_mMHO_TeamProgress[libGame_gv_teamChaosIndex_C] += libSCHO_gv_mMHO_ControlBeaconProgressIncrement_C;
                libAIAI_gf_AITeamDelegateAdjustMapEventProgressforTeam(TruncI(libSCHO_gv_mMHO_ControlBeaconProgressIncrement_C), libGame_gv_teamChaosIndex_C);
                if ((libSCHO_gv_mMHO_TeamProgress[libGame_gv_teamChaosIndex_C] > 100.0)) {
                    libSCHO_gv_mMHO_TeamProgress[libGame_gv_teamChaosIndex_C] = 100.0;
                }

                UnitSetPropertyFixed(libSCHO_gv_mMHO_ChaosProgressUnit, c_unitPropLife, libSCHO_gv_mMHO_TeamProgress[libGame_gv_teamChaosIndex_C]);
                libNtve_gf_SetDialogItemText(libSCHO_gv_mMHOPanel.lv_beaconProgressHPBarLabel[1][2], (FixedToText(libSCHO_gv_mMHO_TeamProgress[libGame_gv_teamChaosIndex_C], 0) + StringExternal("Param/Value/lib_SCHO_675546D1")), PlayerGroupAll());
                libNtve_gf_SetDialogItemText(libSCHO_gv_mMHOPanel.lv_beaconProgressHPBarLabel[2][2], (FixedToText(libSCHO_gv_mMHO_TeamProgress[libGame_gv_teamChaosIndex_C], 0) + StringExternal("Param/Value/lib_SCHO_EAFC236F")), PlayerGroupAll());
                DialogControlSendAnimationEvent(libSCHO_gv_mMHOPanel.lv_beaconProgressFrame[1], PlayerGroupAll(), "BottomBarPulse");
                DialogControlSendAnimationEvent(libSCHO_gv_mMHOPanel.lv_beaconProgressFrame[2], PlayerGroupAll(), "TopBarPulse");
                libSCHO_gf_MMHOPeriodicallySpawnZergUnits(libGame_gv_teamChaosIndex_C);
            }
            else {
                libSCHO_gv_mMHO_TeamProgress[libGame_gv_teamChaosIndex_C] = 100.0;
            }
        }
        else {
        }
        if (((libSCHO_gv_mMHO_TeamProgress[libGame_gv_teamOrderIndex_C] >= 100.0) || (libSCHO_gv_mMHO_TeamProgress[libGame_gv_teamChaosIndex_C] >= 100.0))) {
            libSCHO_gf_MMHOTransmissionBeaconsFullyCaptured(libSCHO_gv_mMHO_TeamProgress[libGame_gv_teamOrderIndex_C], libSCHO_gv_mMHO_TeamProgress[libGame_gv_teamChaosIndex_C]);
            libSCHO_gf_MMHOHiveCageFullyCharged();
            return true;
        }

        Wait(libSCHO_gv_mMHO_ControlBeaconProgressTime_C, c_timeGame);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libSCHO_gt_MMHOHiveControlBeaconMonitor_Init () {
    libSCHO_gt_MMHOHiveControlBeaconMonitor = TriggerCreate("libSCHO_gt_MMHOHiveControlBeaconMonitor_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMHO Animate Factory
//--------------------------------------------------------------------------------------------------
bool libSCHO_gt_MMHOAnimateFactory_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_index;

    // Automatic Variable Declarations
    timer auto61AC3838_val;

    // Variable Initialization

    // Actions
    if (!runActions) {
        return true;
    }

    auto61AC3838_val = EventTimer();
    if (auto61AC3838_val == libSCHO_gv_mMHO_Factory_Timer[1].lv_animationTimer) {
        lv_index = 1;
    }
    else if (auto61AC3838_val == libSCHO_gv_mMHO_Factory_Timer[2].lv_animationTimer) {
        lv_index = 2;
    }
    else if (auto61AC3838_val == libSCHO_gv_mMHO_Factory_Timer[3].lv_animationTimer) {
        lv_index = 3;
    }
    else if (auto61AC3838_val == libSCHO_gv_mMHO_Factory_Timer[4].lv_animationTimer) {
        lv_index = 4;
    }
    else if (auto61AC3838_val == libSCHO_gv_mMHO_Factory_Timer[5].lv_animationTimer) {
        lv_index = 5;
    }
    else if (auto61AC3838_val == libSCHO_gv_mMHO_Factory_Timer[6].lv_animationTimer) {
        lv_index = 6;
    }
    else {
    }
    ActorSend(ActorFromDoodad(libSCHO_gv_mMHO_FactoryMercCampDoodads[lv_index]), "Signal CampSpawned");
    return true;
}

//--------------------------------------------------------------------------------------------------
void libSCHO_gt_MMHOAnimateFactory_Init () {
    libSCHO_gt_MMHOAnimateFactory = TriggerCreate("libSCHO_gt_MMHOAnimateFactory_Func");
    TriggerAddEventTimer(libSCHO_gt_MMHOAnimateFactory, libSCHO_gv_mMHO_Factory_Timer[1].lv_animationTimer);
    TriggerAddEventTimer(libSCHO_gt_MMHOAnimateFactory, libSCHO_gv_mMHO_Factory_Timer[2].lv_animationTimer);
    TriggerAddEventTimer(libSCHO_gt_MMHOAnimateFactory, libSCHO_gv_mMHO_Factory_Timer[3].lv_animationTimer);
    TriggerAddEventTimer(libSCHO_gt_MMHOAnimateFactory, libSCHO_gv_mMHO_Factory_Timer[4].lv_animationTimer);
    TriggerAddEventTimer(libSCHO_gt_MMHOAnimateFactory, libSCHO_gv_mMHO_Factory_Timer[5].lv_animationTimer);
    TriggerAddEventTimer(libSCHO_gt_MMHOAnimateFactory, libSCHO_gv_mMHO_Factory_Timer[6].lv_animationTimer);
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMHO Merc Camp Spawned
//--------------------------------------------------------------------------------------------------
bool libSCHO_gt_MMHOMercCampSpawned_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_index;

    // Automatic Variable Declarations
    // Variable Initialization

    // Actions
    if (!runActions) {
        return true;
    }

    lv_index = libGame_gf_JungleCampSpawningIndex();
    if ((TimerGetRemaining(libSCHO_gv_mMHO_Factory_Timer[lv_index].lv_animationTimer) > 1)) {
        TimerStart(libSCHO_gv_mMHO_Factory_Timer[lv_index].lv_animationTimer, 0.0625, false, c_timeGame);
    }

    if ((lv_index == 5)) {
        if ((TimerGetRemaining(libSCHO_gv_mMHO_Elevator.lv_elevatorInitialRaiseTimer) > 1)) {
            TimerStart(libSCHO_gv_mMHO_Elevator.lv_elevatorInitialRaiseTimer, 0.0625, false, c_timeGame);
        }

        if ((TimerGetRemaining(libSCHO_gv_mMHO_Elevator.lv_elevatorLowerTimer) > 1)) {
            TimerStart(libSCHO_gv_mMHO_Elevator.lv_elevatorLowerTimer, 0.0625, false, c_timeGame);
        }

    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libSCHO_gt_MMHOMercCampSpawned_Init () {
    libSCHO_gt_MMHOMercCampSpawned = TriggerCreate("libSCHO_gt_MMHOMercCampSpawned_Func");
    libGame_gf_JungleCampSpawning(libSCHO_gt_MMHOMercCampSpawned);
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMHO Merc Camp Cleared
//--------------------------------------------------------------------------------------------------
bool libSCHO_gt_MMHOMercCampCleared_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_index;

    // Automatic Variable Declarations
    // Variable Initialization

    // Actions
    if (!runActions) {
        return true;
    }

    lv_index = libGame_gf_MercCampCapturedIndex();
    ActorSend(ActorFromDoodad(libSCHO_gv_mMHO_FactoryMercCampDoodads[lv_index]), "Signal CampCleared");
    if ((libMapM_gv_jungleCreepCamps[lv_index].lv_mapDataCampDefenderType != libMapM_ge_JungleCampDefenderTypes_BossCamp1)) {
        TimerStart(libSCHO_gv_mMHO_Factory_Timer[lv_index].lv_animationTimer, (libMapM_gv_jungleCreepCamps[lv_index].lv_defenderRespawnTime-libSCHO_gv_mMHO_Factory_Anim_Headstart_C), false, c_timeGame);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libSCHO_gt_MMHOMercCampCleared_Init () {
    libSCHO_gt_MMHOMercCampCleared = TriggerCreate("libSCHO_gt_MMHOMercCampCleared_Func");
    libGame_gf_MercCampCaptured(libSCHO_gt_MMHOMercCampCleared);
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMHO Archangel Is Captured
//--------------------------------------------------------------------------------------------------
bool libSCHO_gt_MMHOArchangelIsCaptured_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((libGame_gf_MercCampCapturedIndex() == 5))) {
            return false;
        }
    }

    // Actions
    if (!runActions) {
        return true;
    }

    TimerStart(libSCHO_gv_mMHO_Elevator.lv_elevatorLowerTimer, (libMapM_gv_jungleCreepCamps[5].lv_defenderRespawnTime -15), false, c_timeGame);
    libSCHO_gf_MMHOSpawnLanerArchangel(libGame_gf_TeamNumberOfPlayer(libGame_gf_MercCampCapturedOwner()), libGame_gf_MercCampCapturedIndex());
    libSCHO_gf_MMHODelayElevatorLowering();
    return true;
}

//--------------------------------------------------------------------------------------------------
void libSCHO_gt_MMHOArchangelIsCaptured_Init () {
    libSCHO_gt_MMHOArchangelIsCaptured = TriggerCreate("libSCHO_gt_MMHOArchangelIsCaptured_Func");
    libGame_gf_MercCampCaptured(libSCHO_gt_MMHOArchangelIsCaptured);
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMHO Archangel Dies
//--------------------------------------------------------------------------------------------------
bool libSCHO_gt_MMHOArchangelDies_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libSCHO_gv_mMHO_ArchangelWinningTeam = 0;
    libSCHO_gv_mMHO_ArchangelCurrentPathIndex = 1;
    libSCHO_gv_mMHO_ArchangelPathIndexMax = 1;
    PathDestroy(libSCHO_gv_mMHO_ArchangelLanerPathLine);
    PingDestroy(libSCHO_gv_mMHO_ArchangelLanerPing[0]);
    PingDestroy(libSCHO_gv_mMHO_ArchangelLanerPing[1]);
    PingDestroy(libSCHO_gv_mMHO_ArchangelLanerPing[2]);
    TriggerEnable(TriggerGetCurrent(), false);
    TriggerEnable(libSCHO_gt_MMHOArchangelUpdateMercPath, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libSCHO_gt_MMHOArchangelDies_Init () {
    libSCHO_gt_MMHOArchangelDies = TriggerCreate("libSCHO_gt_MMHOArchangelDies_Func");
    TriggerEnable(libSCHO_gt_MMHOArchangelDies, false);
    TriggerAddEventUnitDied(libSCHO_gt_MMHOArchangelDies, UnitRefFromVariable("libSCHO_gv_mMHO_ArchangelLaner"));
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMHO Archangel Defender Spawned
//--------------------------------------------------------------------------------------------------
bool libSCHO_gt_MMHOArchangelDefenderSpawned_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((UnitGetType(libGame_gf_JungleCampDefenderUnit()) == "TerranArchangelDefender"))) {
            return false;
        }
    }

    // Actions
    if (!runActions) {
        return true;
    }

    if ((libSCHO_gv_mMHO_Elevator.lv_elevatorWasLowered == false)) {
        libNtve_gf_SendActorMessageToUnit(libGame_gf_JungleCampDefenderUnit(), "SetVisibility 1");
        libNtve_gf_SendActorMessageToUnit(libGame_gf_JungleCampDefenderUnit(), "Signal FlyingBirth");
    }

    Wait(3.0, c_timeGame);
    libSCHO_gf_MMHOElevatorAddRemoveUnpathable(false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libSCHO_gt_MMHOArchangelDefenderSpawned_Init () {
    libSCHO_gt_MMHOArchangelDefenderSpawned = TriggerCreate("libSCHO_gt_MMHOArchangelDefenderSpawned_Func");
    libGame_gf_JungleCampDefenderCreated(libSCHO_gt_MMHOArchangelDefenderSpawned);
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMHO Archangel Update Merc Path
//--------------------------------------------------------------------------------------------------
bool libSCHO_gt_MMHOArchangelUpdateMercPath_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libSCHO_gv_mMHO_ArchangelCurrentPathIndex += 1;
    libSCHO_gf_MMHOCreateArchangelPathLine(libSCHO_gv_mMHO_ArchangelLaner, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libSCHO_gt_MMHOArchangelUpdateMercPath_Init () {
    libSCHO_gt_MMHOArchangelUpdateMercPath = TriggerCreate("libSCHO_gt_MMHOArchangelUpdateMercPath_Func");
    TriggerEnable(libSCHO_gt_MMHOArchangelUpdateMercPath, false);
    TriggerAddEventUnitNextWaypointUpdated(libSCHO_gt_MMHOArchangelUpdateMercPath, UnitRefFromVariable("libSCHO_gv_mMHO_ArchangelLaner"));
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMHO Add Unpathable Location At Start
//--------------------------------------------------------------------------------------------------
bool libSCHO_gt_MMHOAddUnpathableLocationAtStart_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libSCHO_gf_MMHOElevatorAddRemoveUnpathable(true);
    libSCHO_gv_mMHO_ArchangelElevator_ShouldBeLowered = true;
    return true;
}

//--------------------------------------------------------------------------------------------------
void libSCHO_gt_MMHOAddUnpathableLocationAtStart_Init () {
    libSCHO_gt_MMHOAddUnpathableLocationAtStart = TriggerCreate("libSCHO_gt_MMHOAddUnpathableLocationAtStart_Func");
    TriggerAddEventTimer(libSCHO_gt_MMHOAddUnpathableLocationAtStart, libGame_gv_openTheGatesTimer);
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMHO Elevator Initial Timer Expires
//--------------------------------------------------------------------------------------------------
bool libSCHO_gt_MMHOElevatorInitialTimerExpires_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    ActorSend(ActorFromDoodad(libSCHO_gv_mMHO_ArchangelElevator), "Signal Up");
    return true;
}

//--------------------------------------------------------------------------------------------------
void libSCHO_gt_MMHOElevatorInitialTimerExpires_Init () {
    libSCHO_gt_MMHOElevatorInitialTimerExpires = TriggerCreate("libSCHO_gt_MMHOElevatorInitialTimerExpires_Func");
    TriggerAddEventTimer(libSCHO_gt_MMHOElevatorInitialTimerExpires, libSCHO_gv_mMHO_Elevator.lv_elevatorInitialRaiseTimer);
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMHO Elevator Lower Timer Expires
//--------------------------------------------------------------------------------------------------
bool libSCHO_gt_MMHOElevatorLowerTimerExpires_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    if ((libSCHO_gv_mMHO_ArchangelElevator_ShouldBeLowered == true)) {
        libSCHO_gv_mMHO_ArchangelElevator_ShouldBeLowered = false;
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libSCHO_gt_MMHOElevatorLowerTimerExpires_Init () {
    libSCHO_gt_MMHOElevatorLowerTimerExpires = TriggerCreate("libSCHO_gt_MMHOElevatorLowerTimerExpires_Func");
    TriggerAddEventTimer(libSCHO_gt_MMHOElevatorLowerTimerExpires, libSCHO_gv_mMHO_Elevator.lv_elevatorLowerTimer);
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMHO Elevator Raise Timer Expires
//--------------------------------------------------------------------------------------------------
bool libSCHO_gt_MMHOElevatorRaiseTimerExpires_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    if ((libSCHO_gv_mMHO_Elevator.lv_elevatorWasLowered == true)) {
        ActorSend(ActorFromDoodad(libSCHO_gv_mMHO_ArchangelElevator), "Signal Up");
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libSCHO_gt_MMHOElevatorRaiseTimerExpires_Init () {
    libSCHO_gt_MMHOElevatorRaiseTimerExpires = TriggerCreate("libSCHO_gt_MMHOElevatorRaiseTimerExpires_Func");
    TriggerAddEventTimer(libSCHO_gt_MMHOElevatorRaiseTimerExpires, libSCHO_gv_mMHO_Elevator.lv_elevatorRaiseTimer);
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMHO Zerg Attacks Enemy
//--------------------------------------------------------------------------------------------------
bool libSCHO_gt_MMHOZergAttacksEnemy_Func (bool testConds, bool runActions) {
    // Variable Declarations
    const fixed lv_dropPodTouchdownDistanceBeyondTarget_C = 3.0;
    const fixed lv_dropPodTouchdownAreaRadius_C = 3.0;
    unit lv_attackingUnit;
    unit lv_enemyUnit;
    int lv_attackingTeam;
    int lv_enemyComputer;
    fixed lv_angleFromAttackerToEnemy;
    point lv_dropPodTouchdownCenter;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_attackingUnit = EventPlayerEffectUsedUnit(c_effectUnitCaster);
    lv_enemyUnit = EventPlayerEffectUsedUnit(c_effectUnitTarget);

    // Conditions
    if (testConds) {
        if (!((lv_attackingUnit != null))) {
            return false;
        }

        if (!((libGame_gv_gameOver == false))) {
            return false;
        }
    }

    // Actions
    if (!runActions) {
        return true;
    }

    lv_attackingTeam = libGame_gf_TeamNumberOfPlayer(UnitGetOwner(lv_attackingUnit));
    if (((libSCHO_gv_zergDropPodDropsRemaining[lv_attackingTeam] > 0.0) && (TimerGetRemaining(libSCHO_gv_zergDropPodCooldowns[lv_attackingTeam]) <= 0.0))) {
        lv_enemyComputer = UnitGetOwner(lv_enemyUnit);
        lv_angleFromAttackerToEnemy = AngleBetweenPoints(UnitGetPosition(lv_attackingUnit), UnitGetPosition(lv_enemyUnit));
        lv_dropPodTouchdownCenter = PointWithOffsetPolar(UnitGetPosition(lv_enemyUnit), lv_dropPodTouchdownDistanceBeyondTarget_C, lv_angleFromAttackerToEnemy);
        libSCHO_gf_MMHOCreateDropPod(RegionRandomPoint(RegionCircle(lv_dropPodTouchdownCenter, lv_dropPodTouchdownAreaRadius_C)), libGame_gf_ComputerPlayerInTeam(lv_attackingTeam));
        TimerStart(libSCHO_gv_zergDropPodCooldowns[lv_attackingTeam], libSCHO_gv_zergDropPodCooldownTime_C, false, c_timeGame);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libSCHO_gt_MMHOZergAttacksEnemy_Init () {
    libSCHO_gt_MMHOZergAttacksEnemy = TriggerCreate("libSCHO_gt_MMHOZergAttacksEnemy_Func");
    TriggerAddEventPlayerEffectUsed(libSCHO_gt_MMHOZergAttacksEnemy, c_playerAny, "ZergUltraliskWeaponDamage");
    TriggerAddEventPlayerEffectUsed(libSCHO_gt_MMHOZergAttacksEnemy, c_playerAny, "ZergGuardianWeaponDamage");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMHO Scaling Timer Expires
//--------------------------------------------------------------------------------------------------
bool libSCHO_gt_MMHOScalingTimerExpires_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libSCHO_gv_mMHO_ScalingLevel += 1.0;
    libSCHO_gf_MMHOUpdateTerranScaling();
    TimerStart(libSCHO_gv_mMHO_ScalingTimer, 60.0, false, c_timeGame);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libSCHO_gt_MMHOScalingTimerExpires_Init () {
    libSCHO_gt_MMHOScalingTimerExpires = TriggerCreate("libSCHO_gt_MMHOScalingTimerExpires_Func");
    TriggerAddEventTimer(libSCHO_gt_MMHOScalingTimerExpires, libSCHO_gv_mMHO_ScalingTimer);
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMHO Zerg Unit Takes Damage
//--------------------------------------------------------------------------------------------------
bool libSCHO_gt_MMHOZergUnitTakesDamage_Func (bool testConds, bool runActions) {
    // Variable Declarations
    fixed lv_damageAmount;
    int lv_team;

    // Automatic Variable Declarations
    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((((UnitGroupHasUnit(libSCHO_gv_mMHO_AttackGroups[1][1], EventUnit()) == true) || (UnitGroupHasUnit(libSCHO_gv_mMHO_AttackGroups[1][2], EventUnit()) == true) || (UnitGroupHasUnit(libSCHO_gv_mMHO_AttackGroups[2][1], EventUnit()) == true) || (UnitGroupHasUnit(libSCHO_gv_mMHO_AttackGroups[2][2], EventUnit()) == true)) && ((UnitGetType(EventUnit()) == "ZergUltralisk") || (UnitGetType(EventUnit()) == "ZergGuardian"))))) {
            return false;
        }
    }

    // Actions
    if (!runActions) {
        return true;
    }

    lv_team = libGame_gf_TeamNumberOfPlayer(UnitGetOwner(EventUnit()));
    if ((UnitGetType(EventUnit()) == "ZergUltralisk")) {
        lv_damageAmount = (EventUnitDamageAmount() * libSCHO_gv_mMHO_UltraliskHealthWeighting);
    }
    else if ((UnitGetType(EventUnit()) == "ZergGuardian")) {
        lv_damageAmount = (EventUnitDamageAmount() * libSCHO_gv_mMHO_GuardianHealthWeighting);
    }
    libSCHO_gv_mMHO_TotalZergHP[lv_team] -= lv_damageAmount;
    libSCHO_gf_MMHOEndofMatchAwardZergCrusherModifyValuesandReport(EventUnitDamageSourcePlayer(), lv_damageAmount);
    if ((lv_team == libGame_gv_teamOrderIndex_C)) {
        if ((lv_damageAmount >= UnitGetPropertyFixed(libSCHO_gv_mMHO_OrderProgressUnit, c_unitPropLife, c_unitPropCurrent))) {
            UnitSetPropertyFixed(libSCHO_gv_mMHO_OrderProgressUnit, c_unitPropLife, 1.0);
        }
        else {
            UnitSetPropertyFixed(libSCHO_gv_mMHO_OrderProgressUnit, c_unitPropLife, libSCHO_gv_mMHO_TotalZergHP[libGame_gv_teamOrderIndex_C]);
        }
        libNtve_gf_SetDialogItemText(libSCHO_gv_mMHOPanel.lv_beaconProgressHPBarLabel[1][1], (FixedToText(UnitGetPropertyFixed(libSCHO_gv_mMHO_OrderProgressUnit, c_unitPropLifePercent, c_unitPropCurrent), 0) + StringExternal("Param/Value/lib_SCHO_F53920F9")), PlayerGroupAll());
        libNtve_gf_SetDialogItemText(libSCHO_gv_mMHOPanel.lv_beaconProgressHPBarLabel[2][1], (FixedToText(UnitGetPropertyFixed(libSCHO_gv_mMHO_OrderProgressUnit, c_unitPropLifePercent, c_unitPropCurrent), 0) + StringExternal("Param/Value/lib_SCHO_D3691337")), PlayerGroupAll());
        if ((libSCHO_gv_mMHO_TotalZergHP[libGame_gv_teamOrderIndex_C] == 0.0)) {
            libSCHO_gf_MMHOUISetZergSwarmKilled(libGame_gv_teamOrderIndex_C);
        }

    }
    else {
        if ((lv_damageAmount >= UnitGetPropertyFixed(libSCHO_gv_mMHO_ChaosProgressUnit, c_unitPropLife, c_unitPropCurrent))) {
            UnitSetPropertyFixed(libSCHO_gv_mMHO_ChaosProgressUnit, c_unitPropLife, 1.0);
        }
        else {
            UnitSetPropertyFixed(libSCHO_gv_mMHO_ChaosProgressUnit, c_unitPropLife, libSCHO_gv_mMHO_TotalZergHP[libGame_gv_teamChaosIndex_C]);
        }
        libNtve_gf_SetDialogItemText(libSCHO_gv_mMHOPanel.lv_beaconProgressHPBarLabel[1][2], (FixedToText(UnitGetPropertyFixed(libSCHO_gv_mMHO_ChaosProgressUnit, c_unitPropLifePercent, c_unitPropCurrent), 0) + StringExternal("Param/Value/lib_SCHO_E2F22591")), PlayerGroupAll());
        libNtve_gf_SetDialogItemText(libSCHO_gv_mMHOPanel.lv_beaconProgressHPBarLabel[2][2], (FixedToText(UnitGetPropertyFixed(libSCHO_gv_mMHO_ChaosProgressUnit, c_unitPropLifePercent, c_unitPropCurrent), 0) + StringExternal("Param/Value/lib_SCHO_E9021DB9")), PlayerGroupAll());
        if ((libSCHO_gv_mMHO_TotalZergHP[libGame_gv_teamChaosIndex_C] == 0.0)) {
            libSCHO_gf_MMHOUISetZergSwarmKilled(libGame_gv_teamChaosIndex_C);
        }

    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libSCHO_gt_MMHOZergUnitTakesDamage_Init () {
    libSCHO_gt_MMHOZergUnitTakesDamage = TriggerCreate("libSCHO_gt_MMHOZergUnitTakesDamage_Func");
    TriggerAddEventUnitDamaged(libSCHO_gt_MMHOZergUnitTakesDamage, null, c_unitDamageTypeAny, c_unitDamageEither, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMHO Zerg Icon Unit Dies
//--------------------------------------------------------------------------------------------------
bool libSCHO_gt_MMHOZergIconUnitDies_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libSCHO_gf_MMHOUpdateZergMinimapIcons(libGame_gf_TeamNumberOfPlayer(EventPlayer()));
    libSCHO_gf_MMHOCreateZergPath(libGame_gf_TeamNumberOfPlayer(EventPlayer()), true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libSCHO_gt_MMHOZergIconUnitDies_Init () {
    libSCHO_gt_MMHOZergIconUnitDies = TriggerCreate("libSCHO_gt_MMHOZergIconUnitDies_Func");
    TriggerAddEventUnitDied(libSCHO_gt_MMHOZergIconUnitDies, UnitRefFromVariable("libSCHO_gv_mMHO_ZergIconUnit[libGame_gv_teamOrderIndex_C].lv_iconUnit"));
    TriggerAddEventUnitDied(libSCHO_gt_MMHOZergIconUnitDies, UnitRefFromVariable("libSCHO_gv_mMHO_ZergIconUnit[libGame_gv_teamChaosIndex_C].lv_iconUnit"));
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMHO Update Zerg Path
//--------------------------------------------------------------------------------------------------
bool libSCHO_gt_MMHOUpdateZergPath_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    if ((EventUnit() == libSCHO_gv_mMHO_ZergIconUnit[libGame_gv_teamOrderIndex_C].lv_iconUnit)) {
        libSCHO_gv_mMHO_ZergCurrentPathIndex[libGame_gv_teamOrderIndex_C] += 1;
        libSCHO_gf_MMHOCreateZergPath(libGame_gv_teamOrderIndex_C, false);
        return true;
    }

    if ((EventUnit() == libSCHO_gv_mMHO_ZergIconUnit[libGame_gv_teamChaosIndex_C].lv_iconUnit)) {
        libSCHO_gv_mMHO_ZergCurrentPathIndex[libGame_gv_teamChaosIndex_C] += 1;
        libSCHO_gf_MMHOCreateZergPath(libGame_gv_teamChaosIndex_C, false);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libSCHO_gt_MMHOUpdateZergPath_Init () {
    libSCHO_gt_MMHOUpdateZergPath = TriggerCreate("libSCHO_gt_MMHOUpdateZergPath_Func");
    TriggerEnable(libSCHO_gt_MMHOUpdateZergPath, false);
    TriggerAddEventUnitNextWaypointUpdated(libSCHO_gt_MMHOUpdateZergPath, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMHO UI Mod Initialize
//--------------------------------------------------------------------------------------------------
bool libSCHO_gt_MMHOUIModInitialize_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libSCHO_gf_MMHOUIInit(libUIUI_gv_mapMechanicsPanel.lv_mainPanel);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libSCHO_gt_MMHOUIModInitialize_Init () {
    libSCHO_gt_MMHOUIModInitialize = TriggerCreate("libSCHO_gt_MMHOUIModInitialize_Func");
    libCore_gf_IncludeModInitialization(libSCHO_gt_MMHOUIModInitialize);
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMHO UI Handler
//--------------------------------------------------------------------------------------------------
bool libSCHO_gt_MMHOUIHandler_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_state;
    int lv_lastState;
    int lv_itTeam;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_state = libSCHO_ge_MMHOUIModes_Idle;
    lv_lastState = libSCHO_ge_MMHOUIModes_Idle;

    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

    // Actions
    if (!runActions) {
        return true;
    }

    TriggerEnable(TriggerGetCurrent(), false);
    while (true) {
        if ((TimerIsPaused(libSCHO_gv_mMHO_AttackEventWarningTimer) == false) && (TimerGetRemaining(libSCHO_gv_mMHO_AttackEventWarningTimer) > 0.0)) {
            lv_state = libSCHO_ge_MMHOUIModes_ZergWarning;
            if ((lv_state != lv_lastState)) {
                libSCHO_gf_MMHOUISetMode(libSCHO_ge_MMHOUIModes_ZergWarning);
            }

            libSCHO_gf_MMHOUISetZergWarningTime(FixedToInt(TimerGetRemaining(libSCHO_gv_mMHO_AttackEventWarningTimer)));
            lv_lastState = lv_state;
        }
        else if ((libSCHO_gv_mMHO_HiveControlBeaconEventActive == true) && (TimerGetRemaining(libSCHO_gv_mMHO_AttackEventWarningTimer) <= 0.0)) {
            lv_state = libSCHO_ge_MMHOUIModes_BeaconEvent;
            if ((lv_state != lv_lastState)) {
                libSCHO_gf_MMHOUISetMode(libSCHO_ge_MMHOUIModes_BeaconEvent);
                libSCHO_gf_MMHOUICreateProgressUnits();
                libSCHO_gf_MMHOUISetProgressUnits();
            }

            lv_lastState = lv_state;
        }
        else if (true) {
            lv_state = libSCHO_ge_MMHOUIModes_Idle;
            if ((lv_state != lv_lastState)) {
                libSCHO_gf_MMHOUISetMode(libSCHO_ge_MMHOUIModes_Idle);
            }

            lv_lastState = lv_state;
        }
        Wait(0.5, c_timeGame);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libSCHO_gt_MMHOUIHandler_Init () {
    libSCHO_gt_MMHOUIHandler = TriggerCreate("libSCHO_gt_MMHOUIHandler_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Debug - EVENTSTART
//--------------------------------------------------------------------------------------------------
bool libSCHO_gt_DebugEVENTSTART_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {
            return false;
        }
    }

    // Actions
    if (!runActions) {
        return true;
    }

    TimerStart(libSCHO_gv_mMHO_AttackEventTimer, 1.0, false, c_timeGame);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libSCHO_gt_DebugEVENTSTART_Init () {
    libSCHO_gt_DebugEVENTSTART = TriggerCreate("libSCHO_gt_DebugEVENTSTART_Func");
    TriggerAddEventChatMessage(libSCHO_gt_DebugEVENTSTART, c_playerAny, "EVENTSTART", true);
    TriggerAddEventChatMessage(libSCHO_gt_DebugEVENTSTART, c_playerAny, "eventstart", true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Debug - EVENTSTART FAST
//--------------------------------------------------------------------------------------------------
bool libSCHO_gt_DebugEVENTSTARTFAST_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {
            return false;
        }
    }

    // Actions
    if (!runActions) {
        return true;
    }

    TimerStart(libSCHO_gv_mMHO_AttackEventWarningTimer, 1.0, false, c_timeGame);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libSCHO_gt_DebugEVENTSTARTFAST_Init () {
    libSCHO_gt_DebugEVENTSTARTFAST = TriggerCreate("libSCHO_gt_DebugEVENTSTARTFAST_Func");
    TriggerAddEventChatMessage(libSCHO_gt_DebugEVENTSTARTFAST, c_playerAny, "EVENTSTART 0", true);
    TriggerAddEventChatMessage(libSCHO_gt_DebugEVENTSTARTFAST, c_playerAny, "eventstart 0", true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Debug - RespawnCamps
//--------------------------------------------------------------------------------------------------
bool libSCHO_gt_DebugRespawnCamps_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {
            return false;
        }
    }

    // Actions
    if (!runActions) {
        return true;
    }

    if ((libSCHO_gv_mMHO_Elevator.lv_elevatorWasLowered == true)) {
        ActorSend(ActorFromDoodad(libSCHO_gv_mMHO_ArchangelElevator), "Signal Up");
        while (!((UnitGetOwner(EventUnit()) == 1))) {
            Wait(1.0, c_timeGame);
        }
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libSCHO_gt_DebugRespawnCamps_Init () {
    libSCHO_gt_DebugRespawnCamps = TriggerCreate("libSCHO_gt_DebugRespawnCamps_Func");
    TriggerAddEventChatMessage(libSCHO_gt_DebugRespawnCamps, c_playerAny, "respawncamps", true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Debug - Test Wave
//--------------------------------------------------------------------------------------------------
bool libSCHO_gt_DebugTestWave_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {
            return false;
        }
    }

    // Actions
    if (!runActions) {
        return true;
    }

    libNtve_gf_CreateUnitsAtPoint2(1, "ZergZergling", c_unitCreateIgnorePlacement, 15, RegionRandomPoint(libSCHO_gv_mMHO_Order_BottomSpawnRegion), null);
    libSCHO_gf_MMHOSendAttackWave(libNtve_gf_ConvertUnitToUnitGroup(UnitLastCreated()), libSCHO_gv_mMHO_AttackPointsFort[2][1], libGame_gv_teamChaosIndex_C);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libSCHO_gt_DebugTestWave_Init () {
    libSCHO_gt_DebugTestWave = TriggerCreate("libSCHO_gt_DebugTestWave_Func");
    TriggerAddEventChatMessage(libSCHO_gt_DebugTestWave, c_playerAny, "-tw", false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Debug - Disable Event
//--------------------------------------------------------------------------------------------------
bool libSCHO_gt_DebugDisableEvent_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {
            return false;
        }
    }

    // Actions
    if (!runActions) {
        return true;
    }

    TimerPause(libSCHO_gv_mMHO_AttackEventTimer, true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libSCHO_gt_DebugDisableEvent_Init () {
    libSCHO_gt_DebugDisableEvent = TriggerCreate("libSCHO_gt_DebugDisableEvent_Func");
    TriggerAddEventChatMessage(libSCHO_gt_DebugDisableEvent, c_playerAny, "-disableevent", true);
}

void libSCHO_InitTriggers () {
    libSCHO_gt_IncludeHoldOut_Init();
    libSCHO_gt_MMHOInitializeMercCampData_Init();
    libSCHO_gt_MMHOInitializePingData_Init();
    libSCHO_gt_MMHOInit_Init();
    libSCHO_gt_MMHOGateOpen_Init();
    libSCHO_gt_MMHOStartWarningTimer_Init();
    libSCHO_gt_MMHOWarningTimerExpires_Init();
    libSCHO_gt_MMHOSpawnAttackWaves_Init();
    libSCHO_gt_MMHOHiveControlBeaconChangesOwner_Init();
    libSCHO_gt_MMHOHiveControlBeaconMonitor_Init();
    libSCHO_gt_MMHOAnimateFactory_Init();
    libSCHO_gt_MMHOMercCampSpawned_Init();
    libSCHO_gt_MMHOMercCampCleared_Init();
    libSCHO_gt_MMHOArchangelIsCaptured_Init();
    libSCHO_gt_MMHOArchangelDies_Init();
    libSCHO_gt_MMHOArchangelDefenderSpawned_Init();
    libSCHO_gt_MMHOArchangelUpdateMercPath_Init();
    libSCHO_gt_MMHOAddUnpathableLocationAtStart_Init();
    libSCHO_gt_MMHOElevatorInitialTimerExpires_Init();
    libSCHO_gt_MMHOElevatorLowerTimerExpires_Init();
    libSCHO_gt_MMHOElevatorRaiseTimerExpires_Init();
    libSCHO_gt_MMHOZergAttacksEnemy_Init();
    libSCHO_gt_MMHOScalingTimerExpires_Init();
    libSCHO_gt_MMHOZergUnitTakesDamage_Init();
    libSCHO_gt_MMHOZergIconUnitDies_Init();
    libSCHO_gt_MMHOUpdateZergPath_Init();
    libSCHO_gt_MMHOUIModInitialize_Init();
    libSCHO_gt_MMHOUIHandler_Init();
    libSCHO_gt_DebugEVENTSTART_Init();
    libSCHO_gt_DebugEVENTSTARTFAST_Init();
    libSCHO_gt_DebugRespawnCamps_Init();
    libSCHO_gt_DebugTestWave_Init();
    libSCHO_gt_DebugDisableEvent_Init();
}

//--------------------------------------------------------------------------------------------------
// Library Initialization
//--------------------------------------------------------------------------------------------------
bool libSCHO_InitLib_completed = false;

void libSCHO_InitLib () {
    if (libSCHO_InitLib_completed) {
        return;
    }

    libSCHO_InitLib_completed = true;

    libSCHO_InitLibraries();
    libSCHO_InitVariables();
    libSCHO_InitTriggers();
}