PTR build 2.57.1.98674_ptr. Go to the live site.

mods/heroesmapmods/battlegroundmapmods/alteracpass.stormmod/base.stormdata/libmmap.galaxy

libmmap.galaxy
include "TriggerLibs/NativeLib"
include "TriggerLibs/HeroesLib"
include "TriggerLibs/GameLib"
include "TriggerLibs/MapMechanicsLib"
include "TriggerLibs/AILib"
include "TriggerLibs/UILib"
include "TriggerLibs/SoundLib"
include "Lib7EB401DE"

include "LibMMAP_h"

//--------------------------------------------------------------------------------------------------
// Library: Alterac Pass
//--------------------------------------------------------------------------------------------------
// External Library Initialization
void libMMAP_InitLibraries () {
    libNtve_InitVariables();
    libCore_InitVariables();
    libGame_InitVariables();
    libMapM_InitVariables();
    libAIAI_InitVariables();
    libUIUI_InitVariables();
    libSond_InitVariables();
    lib7EB401DE_InitVariables();
}

// Variable Initialization
bool libMMAP_InitVariables_completed = false;

void libMMAP_InitVariables () {
    int init_i;
    int init_i1;
    int init_j1;

    if (libMMAP_InitVariables_completed) {
        return;
    }

    libMMAP_InitVariables_completed = true;

    libMMAP_gv_dEBUG_CampDefendersOn = true;
    libMMAP_gv_eventTimer = TimerCreate();
    libMMAP_gv_eventWarningTimer = TimerCreate();
    libMMAP_gv_eventObjectivePreviewTimer = TimerCreate();
    libMMAP_gv_currentCPIndex = RandomInt(1, libMMAP_gv_captureFlagMaxCountForTeam_C);
    for (init_i = 0; init_i <= libCore_gv_bALMaxTeams; init_i += 1) {
        libMMAP_gv_aVMechanics[init_i].lv_cavalrySpawnTimer = TimerCreate();
        libMMAP_gv_aVMechanics[init_i].lv_cavalryUnitGroup = UnitGroupEmpty();
        libMMAP_gv_aVMechanics[init_i].lv_victoryProgress = libMMAP_gv_captureFlagVictoryTimeGoal;
        for (init_i1 = 0; init_i1 <= libMMAP_gv_defenderCountMaximum_C; init_i1 += 1) {
            libMMAP_gv_aVMechanics[init_i].lv_defenderSpawnTimer[init_i1] = TimerCreate();
        }
        libMMAP_gv_aVMechanics[init_i].lv_defenderSpawnShuffler = ShufflerCreate(libMMAP_gv_defenderCountMaximum_C);
        libMMAP_gv_aVMechanics[init_i].lv_flagEnemiesCapturingUnitGroup = UnitGroupEmpty();
        libMMAP_gv_aVMechanics[init_i].lv_flagEnemyHeroesCapturingUnitGroup = UnitGroupEmpty();
        libMMAP_gv_aVMechanics[init_i].lv_eventUnitGroup = UnitGroupEmpty();
    }
    libMMAP_gv_defenderCount = libMMAP_gv_defenderCountStart_C;
    libMMAP_gv_captureFlagVictoryTimeGoal = libMMAP_gv_captureFlagVictoryTimeGoalStart_C;
    libMMAP_gv_aVUI.lv_mainPanel = c_invalidDialogControlId;
    for (init_i1 = 0; init_i1 <= libMMAP_gv_notificationCountMax_C; init_i1 += 1) {
        libMMAP_gv_aVUI.lv_notificationFrame[init_i1] = c_invalidDialogControlId;
    }
    for (init_i1 = 0; init_i1 <= libMMAP_gv_notificationCountMax_C; init_i1 += 1) {
        libMMAP_gv_aVUI.lv_notificationLabel[init_i1] = c_invalidDialogControlId;
    }
    libMMAP_gv_aVUI.lv_mMContainer = c_invalidDialogControlId;
    libMMAP_gv_aVUI.lv_mechanicLabel = c_invalidDialogControlId;
    for (init_i1 = 0; init_i1 <= libCore_gv_bALMaxTeams; init_i1 += 1) {
        libMMAP_gv_aVUI.lv_teamWinningIcon[init_i1] = c_invalidDialogControlId;
    }
    for (init_i1 = 0; init_i1 <= libCore_gv_bALMaxTeams; init_i1 += 1) {
        libMMAP_gv_aVUI.lv_teamWinningIcon_Glow[init_i1] = c_invalidDialogControlId;
    }
    for (init_i1 = 0; init_i1 <= libCore_gv_bALMaxTeams; init_i1 += 1) {
        libMMAP_gv_aVUI.lv_progressBarLabel[init_i1] = c_invalidDialogControlId;
    }
    for (init_i1 = 0; init_i1 <= libCore_gv_bALMaxTeams; init_i1 += 1) {
        libMMAP_gv_aVUI.lv_victoryProgressBar[init_i1] = c_invalidDialogControlId;
    }
    for (init_i1 = 0; init_i1 <= libCore_gv_bALMaxTeams; init_i1 += 1) {
        libMMAP_gv_aVUI.lv_progressBarIconImage[init_i1] = c_invalidDialogControlId;
    }
    for (init_i1 = 0; init_i1 <= libMMAP_gv_aVLaneCount_C; init_i1 += 1) {
        libMMAP_gv_aVUI.lv_mapMechanicHealthBar[init_i1] = c_invalidDialogControlId;
    }
    for (init_i1 = 0; init_i1 <= libCore_gv_bALMaxTeams; init_i1 += 1) {
        for (init_j1 = 0; init_j1 <= libCore_gv_bALMaxTeams; init_j1 += 1) {
            libMMAP_gv_aVUI.lv_cageTextTag[init_i1][init_j1] = c_textTagNone;
        }
    }
    for (init_i1 = 0; init_i1 <= libCore_gv_bALMaxTeams; init_i1 += 1) {
        libMMAP_gv_aVSounds.lv_aVTeamSpecificSounds[init_i1].lv_cavalrySpawnWarning = SoundLink("EditorDefaultSound", -1);
        libMMAP_gv_aVSounds.lv_aVTeamSpecificSounds[init_i1].lv_cavalrySpawn = SoundLink("EditorDefaultSound", -1);
        libMMAP_gv_aVSounds.lv_aVTeamSpecificSounds[init_i1].lv_coreGetHitSmall = SoundLink("EditorDefaultSound", -1);
        libMMAP_gv_aVSounds.lv_aVTeamSpecificSounds[init_i1].lv_coreGetHitLarge = SoundLink("EditorDefaultSound", -1);
    }
    libMMAP_gv_aVTransmissions.lv_campTransmissionCDTimer = TimerCreate();
    libMMAP_gv_transmissionCDTimerDuration_C = 10;
}

// Presets
// Functions
void libMMAP_gf_InitializeMapMVPAnnouncerSounds () {
    // Automatic Variable Declarations
    playergroup auto4A4F15F9_g;
    int auto4A4F15F9_var;
    playergroup auto9CB6EE60_g;
    int auto9CB6EE60_var;

    // Implementation
    auto4A4F15F9_g = GameAttributePlayersForTeam(libGame_gv_teamOrderIndex_C);
    auto4A4F15F9_var = -1;
    while (true) {
        	auto4A4F15F9_var = PlayerGroupNextPlayer(auto4A4F15F9_g, auto4A4F15F9_var);
        	if (auto4A4F15F9_var<0) { break; }
        	libGame_gv_players[auto4A4F15F9_var].lv_lootContent.lv_loot_AnnouncerPack.lv_announcerVOLines[libCore_ge_AnnouncerVOEvents_MVP].lv_soundLink = "VanndarA_MVP";
        libGame_gv_players[auto4A4F15F9_var].lv_lootContent.lv_loot_AnnouncerPack.lv_announcerVOLines[libCore_ge_AnnouncerVOEvents_MVP].lv_playAtGameEnd = true;
        libGame_gv_players[auto4A4F15F9_var].lv_lootContent.lv_loot_AnnouncerPack.lv_announcerVOLines[libCore_ge_AnnouncerVOEvents_MVPVoteEpic].lv_soundLink = "VanndarA_Epic";
        libGame_gv_players[auto4A4F15F9_var].lv_lootContent.lv_loot_AnnouncerPack.lv_announcerVOLines[libCore_ge_AnnouncerVOEvents_MVPVoteEpic].lv_playAtGameEnd = true;
        libGame_gv_players[auto4A4F15F9_var].lv_lootContent.lv_loot_AnnouncerPack.lv_announcerVOLines[libCore_ge_AnnouncerVOEvents_MVPVoteLegendary].lv_soundLink = "VanndarA_Legendary";
        libGame_gv_players[auto4A4F15F9_var].lv_lootContent.lv_loot_AnnouncerPack.lv_announcerVOLines[libCore_ge_AnnouncerVOEvents_MVPVoteLegendary].lv_playAtGameEnd = true;
    }
    auto9CB6EE60_g = GameAttributePlayersForTeam(libGame_gv_teamChaosIndex_C);
    auto9CB6EE60_var = -1;
    while (true) {
        	auto9CB6EE60_var = PlayerGroupNextPlayer(auto9CB6EE60_g, auto9CB6EE60_var);
        	if (auto9CB6EE60_var<0) { break; }
        	libGame_gv_players[auto9CB6EE60_var].lv_lootContent.lv_loot_AnnouncerPack.lv_announcerVOLines[libCore_ge_AnnouncerVOEvents_MVP].lv_soundLink = "DrekTharA_MVP";
        libGame_gv_players[auto9CB6EE60_var].lv_lootContent.lv_loot_AnnouncerPack.lv_announcerVOLines[libCore_ge_AnnouncerVOEvents_MVP].lv_playAtGameEnd = true;
        libGame_gv_players[auto9CB6EE60_var].lv_lootContent.lv_loot_AnnouncerPack.lv_announcerVOLines[libCore_ge_AnnouncerVOEvents_MVPVoteEpic].lv_soundLink = "DrekTharA_Epic";
        libGame_gv_players[auto9CB6EE60_var].lv_lootContent.lv_loot_AnnouncerPack.lv_announcerVOLines[libCore_ge_AnnouncerVOEvents_MVPVoteEpic].lv_playAtGameEnd = true;
        libGame_gv_players[auto9CB6EE60_var].lv_lootContent.lv_loot_AnnouncerPack.lv_announcerVOLines[libCore_ge_AnnouncerVOEvents_MVPVoteLegendary].lv_soundLink = "DrekTharA_Legendary";
        libGame_gv_players[auto9CB6EE60_var].lv_lootContent.lv_loot_AnnouncerPack.lv_announcerVOLines[libCore_ge_AnnouncerVOEvents_MVPVoteLegendary].lv_playAtGameEnd = true;
    }
    libGame_gv_players[libCore_gv_oBSERVER_ObserverUIPlayer].lv_lootContent.lv_loot_AnnouncerPack.lv_announcerVOLines[libCore_ge_AnnouncerVOEvents_MVP].lv_soundLink = "VanndarA_MVP";
    libGame_gv_players[libCore_gv_oBSERVER_ObserverUIPlayer].lv_lootContent.lv_loot_AnnouncerPack.lv_announcerVOLines[libCore_ge_AnnouncerVOEvents_MVP].lv_playAtGameEnd = true;
    libGame_gv_players[libCore_gv_oBSERVER_ObserverUIPlayer].lv_lootContent.lv_loot_AnnouncerPack.lv_announcerVOLines[libCore_ge_AnnouncerVOEvents_MVPVoteEpic].lv_soundLink = "VanndarA_Epic";
    libGame_gv_players[libCore_gv_oBSERVER_ObserverUIPlayer].lv_lootContent.lv_loot_AnnouncerPack.lv_announcerVOLines[libCore_ge_AnnouncerVOEvents_MVPVoteEpic].lv_playAtGameEnd = true;
    libGame_gv_players[libCore_gv_oBSERVER_ObserverUIPlayer].lv_lootContent.lv_loot_AnnouncerPack.lv_announcerVOLines[libCore_ge_AnnouncerVOEvents_MVPVoteLegendary].lv_soundLink = "VanndarA_Legendary";
    libGame_gv_players[libCore_gv_oBSERVER_ObserverUIPlayer].lv_lootContent.lv_loot_AnnouncerPack.lv_announcerVOLines[libCore_ge_AnnouncerVOEvents_MVPVoteLegendary].lv_playAtGameEnd = true;
}

void libMMAP_gf_OverrideMinionWaveComposition () {
    // Variable Declarations
    int lv_composition;
    int lv_group;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_composition = (libCore_ge_MinionWaveCompositionsTypes_Standard);

    // Implementation
    libCore_gv_sYSCustomMinionsEnabled = true;
    libCore_gv_dataMinionData[libCore_ge_MinionTypes_Catapult].lv_unitType = "ReaverMinion";
    libCore_gv_dataMinionWaveCompositions[lv_composition].lv_name = StringExternal("Param/Value/lib_MMAP_F02BC796");
    libCore_gv_dataMinionWaveCompositions[lv_composition].lv_enabled = true;
    lv_group += 1;
    libCore_gv_dataMinionWaveCompositions[lv_composition].lv_groupMinionType[lv_group] = libCore_ge_MinionTypes_Catapult;
    libCore_gv_dataMinionWaveCompositions[lv_composition].lv_groupMinionCount[lv_group] = 1;
    lv_group += 1;
    libCore_gv_dataMinionWaveCompositions[lv_composition].lv_groupMinionType[lv_group] = libCore_ge_MinionTypes_Footmen;
    libCore_gv_dataMinionWaveCompositions[lv_composition].lv_groupMinionCount[lv_group] = 3;
    lv_group += 1;
    libCore_gv_dataMinionWaveCompositions[lv_composition].lv_groupMinionType[lv_group] = libCore_ge_MinionTypes_Wizard;
    libCore_gv_dataMinionWaveCompositions[lv_composition].lv_groupMinionCount[lv_group] = 1;
    lv_group += 1;
    libCore_gv_dataMinionWaveCompositions[lv_composition].lv_groupMinionType[lv_group] = libCore_ge_MinionTypes_Ranged;
    libCore_gv_dataMinionWaveCompositions[lv_composition].lv_groupMinionCount[lv_group] = 3;
    libCore_gv_dataMinionWaveCompositions[lv_composition].lv_numberOfGroups = lv_group;
}

void libMMAP_gf_InitializeFlagData (int lp_team, int lp_flagIndex, region lp_region, region lp_defenderLeashRegion, unit lp_cageUnit, unit lp_cageBannerSconce, point lp_flagSpawnPoint, point lp_flagDummyLockSpawnPoint, point lp_defenderSpawnPoint1, point lp_defenderSpawnPoint2, point lp_defenderSpawnPoint3, point lp_defenderSpawnPoint4, doodad lp_defenderSpawnDoodad1, doodad lp_defenderSpawnDoodad2, doodad lp_defenderSpawnDoodad3, doodad lp_defenderSpawnDoodad4) {
    // Automatic Variable Declarations
    // Implementation
    libMMAP_gv_aVMechanics[lp_team].lv_region[lp_flagIndex] = lp_region;
    libMMAP_gv_aVMechanics[lp_team].lv_defenderLeashRegion[lp_flagIndex] = lp_defenderLeashRegion;
    libMMAP_gv_aVMechanics[lp_team].lv_flagSpawnPoint[lp_flagIndex] = lp_flagSpawnPoint;
    libMMAP_gv_aVMechanics[lp_team].lv_flagDummyLockUnitSpawnPoint[lp_flagIndex] = lp_flagDummyLockSpawnPoint;
    libMMAP_gv_aVMechanics[lp_team].lv_cageUnit[lp_flagIndex] = lp_cageUnit;
    libMMAP_gv_aVMechanics[lp_team].lv_cageBannerSconceUnit[lp_flagIndex] = lp_cageBannerSconce;
    libMMAP_gv_aVMechanics[lp_team].lv_flagCaptureDoodadActor[lp_flagIndex] = libNtve_gf_MainActorofUnit(lp_cageUnit);
    libMMAP_gv_aVMechanics[lp_team].lv_defenderSpawnPoints[lp_flagIndex][1] = lp_defenderSpawnPoint1;
    libMMAP_gv_aVMechanics[lp_team].lv_defenderSpawnPoints[lp_flagIndex][2] = lp_defenderSpawnPoint2;
    libMMAP_gv_aVMechanics[lp_team].lv_defenderSpawnPoints[lp_flagIndex][3] = lp_defenderSpawnPoint3;
    libMMAP_gv_aVMechanics[lp_team].lv_defenderSpawnPoints[lp_flagIndex][4] = lp_defenderSpawnPoint4;
    libMMAP_gv_aVMechanics[lp_team].lv_defenderSpawnDoodadActor[lp_flagIndex][1] = ActorFromDoodad(lp_defenderSpawnDoodad1);
    libMMAP_gv_aVMechanics[lp_team].lv_defenderSpawnDoodadActor[lp_flagIndex][2] = ActorFromDoodad(lp_defenderSpawnDoodad2);
    libMMAP_gv_aVMechanics[lp_team].lv_defenderSpawnDoodadActor[lp_flagIndex][3] = ActorFromDoodad(lp_defenderSpawnDoodad3);
    libMMAP_gv_aVMechanics[lp_team].lv_defenderSpawnDoodadActor[lp_flagIndex][4] = ActorFromDoodad(lp_defenderSpawnDoodad4);
}

void libMMAP_gf_InitializeMapData (int lp_team, region lp_bossAggroRegion, region lp_bossLeashRegion, unit lp_keepTop, unit lp_keepMid, unit lp_keepBot, point lp_cavalrySpawnPointTop, point lp_cavalrySpawnPointMid, point lp_cavalrySpawnPointBot) {
    // Variable Declarations
    int lv_i;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    libMMAP_gv_aVMechanics[lp_team].lv_bossAggroRegion = lp_bossAggroRegion;
    libMMAP_gv_aVMechanics[lp_team].lv_bossLeashRegion = lp_bossLeashRegion;
    libMMAP_gv_aVMechanics[lp_team].lv_keep[libMMAP_ge_AVLanes_Top] = lp_keepTop;
    libMMAP_gv_aVMechanics[lp_team].lv_keep[libMMAP_ge_AVLanes_Mid] = lp_keepMid;
    libMMAP_gv_aVMechanics[lp_team].lv_keep[libMMAP_ge_AVLanes_Bot] = lp_keepBot;
    libMMAP_gv_aVMechanics[lp_team].lv_cavalrySpawnPoint[libMMAP_ge_AVLanes_Top] = lp_cavalrySpawnPointTop;
    libMMAP_gv_aVMechanics[lp_team].lv_cavalrySpawnPoint[libMMAP_ge_AVLanes_Mid] = lp_cavalrySpawnPointMid;
    libMMAP_gv_aVMechanics[lp_team].lv_cavalrySpawnPoint[libMMAP_ge_AVLanes_Bot] = lp_cavalrySpawnPointBot;
}

int libMMAP_gf_TeamNumberOfUnit (unit lp_unit) {
    // Automatic Variable Declarations
    // Implementation
    return libGame_gf_TeamNumberOfPlayer(UnitGetOwner(lp_unit));
}

int libMMAP_gf_NoVisionComputerPlayerInTeam (int lp_team) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_team == libGame_gv_teamOrderIndex_C)) {
        return libCore_gv_cOMPUTER_NoVision_TeamOrder;
    }
    else if ((lp_team == libGame_gv_teamChaosIndex_C)) {
        return libCore_gv_cOMPUTER_NoVision_TeamChaos;
    }
    return 0;
}

int libMMAP_gf_EventWarningTimerDuration (int lp_eventTimerDuration) {
    // Automatic Variable Declarations
    // Implementation
    return (lp_eventTimerDuration - libMMAP_gv_eventTimerWarningDuration_C);
}

void libMMAP_gf_RestartEventTimers () {
    // Variable Declarations
    int lv_gameLengthSubtraction;
    int lv_eventRespawnDuration;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_gameLengthSubtraction = MinI((((FixedToInt(TimerGetElapsed(libGame_gv_gameTimer))/60)*2)), 60);
    lv_eventRespawnDuration = RandomInt((libMMAP_gv_eventRespawnDurationMin_C - lv_gameLengthSubtraction), (libMMAP_gv_eventRespawnDurationMax_C - lv_gameLengthSubtraction));

    // Implementation
    if ((libMMAP_gv_firstEventHasHappened == false)) {
        libMMAP_gv_firstEventHasHappened = true;
    }

    TriggerEnable(libMMAP_gt_EventObjectivePreviewTimerExpires, true);
    TriggerEnable(libMMAP_gt_EventWarningTimerExpires, true);
    TriggerEnable(libMMAP_gt_EventTimerExpires, true);
    TimerStart(libMMAP_gv_eventObjectivePreviewTimer, libMMAP_gv_eventObectivePreviewDuration_C, false, c_timeGame);
    TimerStart(libMMAP_gv_eventTimer, lv_eventRespawnDuration, false, c_timeGame);
    TimerStart(libMMAP_gv_eventWarningTimer, (lv_eventRespawnDuration - libMMAP_gv_eventTimerWarningDuration_C), false, c_timeGame);
}

void libMMAP_gf_DefenderSpawnTimerExpires (int lp_team, timer lp_timer) {
    // Variable Declarations
    int lv_i;

    // Automatic Variable Declarations
    int auto57B92493_ae;
    const int auto57B92493_ai = 1;

    // Variable Initialization

    // Implementation
    auto57B92493_ae = libMMAP_gv_defenderCount;
    lv_i = 1;
    for ( ; ( (auto57B92493_ai >= 0 && lv_i <= auto57B92493_ae) || (auto57B92493_ai < 0 && lv_i >= auto57B92493_ae) ) ; lv_i += auto57B92493_ai ) {
        if ((lp_timer == libMMAP_gv_aVMechanics[lp_team].lv_defenderSpawnTimer[lv_i])) {
            libMMAP_gf_SpawnDefenderForTeamAtCapturePoint(lp_team, lv_i);
            return ;
        }

    }
}

void libMMAP_gf_FlagDefenderDies (unit lp_unit, int lp_team) {
    // Variable Declarations
    int lv_u;

    // Automatic Variable Declarations
    int auto822A6E9D_ae;
    const int auto822A6E9D_ai = 1;

    // Variable Initialization

    // Implementation
    auto822A6E9D_ae = libMMAP_gv_defenderCount;
    lv_u = 1;
    for ( ; ( (auto822A6E9D_ai >= 0 && lv_u <= auto822A6E9D_ae) || (auto822A6E9D_ai < 0 && lv_u >= auto822A6E9D_ae) ) ; lv_u += auto822A6E9D_ai ) {
        if ((lp_unit == libMMAP_gv_aVMechanics[lp_team].lv_defenderUnit[lv_u])) {
            TimerStart(libMMAP_gv_aVMechanics[lp_team].lv_defenderSpawnTimer[lv_u], libMMAP_gv_defenderRespawnTime_C, false, c_timeGame);
            libMMAP_gv_aVMechanics[lp_team].lv_defenderNextSpawnPointIndex[lv_u] = libMMAP_gf_GetDefenderSpawnPointIndex(lp_team);
            ActorSend(libMMAP_gv_aVMechanics[lp_team].lv_defenderSpawnDoodadActor[libMMAP_gv_currentCPIndex][libMMAP_gv_aVMechanics[lp_team].lv_defenderNextSpawnPointIndex[lv_u]], "Signal Work");
            return ;
        }

    }
}

int libMMAP_gf_GetDefenderSpawnPointIndex (int lp_team) {
    // Variable Declarations
    int lv_index;
    int[libMMAP_gv_defenderCountMaximum_C + 1] lv_unusedSpawnPoints;
    int lv_unusedSpawnPointCount;

    // Automatic Variable Declarations
    const int auto839FB4AC_ae = libMMAP_gv_defenderCountMaximum_C;
    int auto839FB4AC_var;

    // Variable Initialization

    // Implementation
    auto839FB4AC_var = 1;
    for ( ; auto839FB4AC_var <= auto839FB4AC_ae; auto839FB4AC_var += 1 ) {
        if ((libMMAP_gv_aVMechanics[lp_team].lv_defenderSpawnPointInUse[auto839FB4AC_var] == false)) {
            lv_unusedSpawnPointCount += 1;
            lv_unusedSpawnPoints[lv_unusedSpawnPointCount] = auto839FB4AC_var;
        }

    }
    lv_index = lv_unusedSpawnPoints[RandomInt(1, lv_unusedSpawnPointCount)];
    libMMAP_gv_aVMechanics[lp_team].lv_defenderSpawnPointInUse[lv_index] = true;
    return lv_index;
}

trigger auto_libMMAP_gf_SpawnDefenderForTeamAtCapturePoint_Trigger = null;
int auto_libMMAP_gf_SpawnDefenderForTeamAtCapturePoint_lp_team;
int auto_libMMAP_gf_SpawnDefenderForTeamAtCapturePoint_lp_unitIndex;

void libMMAP_gf_SpawnDefenderForTeamAtCapturePoint (int lp_team, int lp_unitIndex) {
    auto_libMMAP_gf_SpawnDefenderForTeamAtCapturePoint_lp_team = lp_team;
    auto_libMMAP_gf_SpawnDefenderForTeamAtCapturePoint_lp_unitIndex = lp_unitIndex;

    if (auto_libMMAP_gf_SpawnDefenderForTeamAtCapturePoint_Trigger == null) {
        auto_libMMAP_gf_SpawnDefenderForTeamAtCapturePoint_Trigger = TriggerCreate("auto_libMMAP_gf_SpawnDefenderForTeamAtCapturePoint_TriggerFunc");
    }

    TriggerExecute(auto_libMMAP_gf_SpawnDefenderForTeamAtCapturePoint_Trigger, false, false);
}

bool auto_libMMAP_gf_SpawnDefenderForTeamAtCapturePoint_TriggerFunc (bool testConds, bool runActions) {
    int lp_team = auto_libMMAP_gf_SpawnDefenderForTeamAtCapturePoint_lp_team;
    int lp_unitIndex = auto_libMMAP_gf_SpawnDefenderForTeamAtCapturePoint_lp_unitIndex;

    // Automatic Variable Declarations
    // Implementation
    if ((UnitIsValid(libMMAP_gv_aVMechanics[lp_team].lv_defenderUnit[lp_unitIndex]) == false) && (libMMAP_gv_dEBUG_CampDefendersOn == true)) {
        libNtve_gf_CreateUnitsAtPoint2(1, "AVCapturePointDefender", 0, libGame_gf_ComputerPlayerInTeam(lp_team), libMMAP_gv_aVMechanics[lp_team].lv_defenderSpawnPoints[libMMAP_gv_currentCPIndex][libMMAP_gv_aVMechanics[lp_team].lv_defenderNextSpawnPointIndex[lp_unitIndex]], null);
        libMMAP_gv_aVMechanics[lp_team].lv_defenderUnit[lp_unitIndex] = UnitLastCreated();
        AddUnitOfInterest(libMMAP_gv_aVMechanics[lp_team].lv_defenderUnit[lp_unitIndex], 20.0, 0.0, "KillDefender", libAIAI_gf_ConvertIntegertoGoalTeam(libGame_gf_EnemyTeam(lp_team)), 0);
        libGame_gf_UpdateScalingForUnit(libMMAP_gv_aVMechanics[lp_team].lv_defenderUnit[lp_unitIndex], libGame_gv_scalingTicks, 0);
        UnitGroupAdd(libMMAP_gv_aVMechanics[lp_team].lv_eventUnitGroup, libMMAP_gv_aVMechanics[lp_team].lv_defenderUnit[lp_unitIndex]);
        libMMAP_gf_DefenderMainAILoop(libMMAP_gv_aVMechanics[lp_team].lv_defenderUnit[lp_unitIndex]);
        Wait(0.0625, c_timeGame);
        ActorSend(libMMAP_gv_aVMechanics[lp_team].lv_defenderSpawnDoodadActor[libMMAP_gv_currentCPIndex][libMMAP_gv_aVMechanics[lp_team].lv_defenderNextSpawnPointIndex[lp_unitIndex]], "Signal StopWork");
        libMMAP_gv_aVMechanics[lp_team].lv_defenderSpawnPointInUse[libMMAP_gv_aVMechanics[lp_team].lv_defenderNextSpawnPointIndex[lp_unitIndex]] = false;
    }

    return true;
}

void libMMAP_gf_TrickleSpawnFlagDefenders (int lp_team) {
    // Variable Declarations
    int lv_u;
    fixed lv_staggeredDuration;

    // Automatic Variable Declarations
    int auto0641ADEE_ae;
    const int auto0641ADEE_ai = 1;

    // Variable Initialization
    lv_staggeredDuration = 0.0625;

    // Implementation
    TriggerEnable(libMMAP_gv_aVMechanics[lp_team].lv_defenderDeathTracker, true);
    TriggerEnable(libMMAP_gv_aVMechanics[lp_team].lv_defenderSpawnTracker, true);
    libMMAP_gv_aVMechanics[lp_team].lv_respawnDefenders = true;
    auto0641ADEE_ae = libMMAP_gv_defenderCount;
    lv_u = 1;
    for ( ; ( (auto0641ADEE_ai >= 0 && lv_u <= auto0641ADEE_ae) || (auto0641ADEE_ai < 0 && lv_u >= auto0641ADEE_ae) ) ; lv_u += auto0641ADEE_ai ) {
        if ((UnitIsValid(libMMAP_gv_aVMechanics[lp_team].lv_defenderUnit[lv_u]) == false)) {
            TimerStart(libMMAP_gv_aVMechanics[lp_team].lv_defenderSpawnTimer[lv_u], lv_staggeredDuration, false, c_timeGame);
            libMMAP_gv_aVMechanics[lp_team].lv_defenderNextSpawnPointIndex[lv_u] = libMMAP_gf_GetDefenderSpawnPointIndex(lp_team);
            ActorSend(libMMAP_gv_aVMechanics[lp_team].lv_defenderSpawnDoodadActor[libMMAP_gv_currentCPIndex][libMMAP_gv_aVMechanics[lp_team].lv_defenderNextSpawnPointIndex[lv_u]], "Signal Work");
            lv_staggeredDuration += libMMAP_gv_defenderRespawnTime_C;
        }

    }
}

trigger auto_libMMAP_gf_SpawnAllDefendersImmediately_Trigger = null;
int auto_libMMAP_gf_SpawnAllDefendersImmediately_lp_team;

void libMMAP_gf_SpawnAllDefendersImmediately (int lp_team) {
    auto_libMMAP_gf_SpawnAllDefendersImmediately_lp_team = lp_team;

    if (auto_libMMAP_gf_SpawnAllDefendersImmediately_Trigger == null) {
        auto_libMMAP_gf_SpawnAllDefendersImmediately_Trigger = TriggerCreate("auto_libMMAP_gf_SpawnAllDefendersImmediately_TriggerFunc");
    }

    TriggerExecute(auto_libMMAP_gf_SpawnAllDefendersImmediately_Trigger, false, false);
}

bool auto_libMMAP_gf_SpawnAllDefendersImmediately_TriggerFunc (bool testConds, bool runActions) {
    int lp_team = auto_libMMAP_gf_SpawnAllDefendersImmediately_lp_team;

    // Variable Declarations
    int lv_u;

    // Automatic Variable Declarations
    int auto17B30425_ae;
    const int auto17B30425_ai = 1;

    // Variable Initialization

    // Implementation
    auto17B30425_ae = libMMAP_gv_defenderCount;
    lv_u = 1;
    for ( ; ( (auto17B30425_ai >= 0 && lv_u <= auto17B30425_ae) || (auto17B30425_ai < 0 && lv_u >= auto17B30425_ae) ) ; lv_u += auto17B30425_ai ) {
        libNtve_gf_StopTimer(libMMAP_gv_aVMechanics[lp_team].lv_defenderSpawnTimer[lv_u]);
        libMMAP_gf_SpawnDefenderForTeamAtCapturePoint(lp_team, lv_u);
    }
    return true;
}

trigger auto_libMMAP_gf_DefenderMainAILoop_Trigger = null;
unit auto_libMMAP_gf_DefenderMainAILoop_lp_defenderUnit;

void libMMAP_gf_DefenderMainAILoop (unit lp_defenderUnit) {
    auto_libMMAP_gf_DefenderMainAILoop_lp_defenderUnit = lp_defenderUnit;

    if (auto_libMMAP_gf_DefenderMainAILoop_Trigger == null) {
        auto_libMMAP_gf_DefenderMainAILoop_Trigger = TriggerCreate("auto_libMMAP_gf_DefenderMainAILoop_TriggerFunc");
    }

    TriggerExecute(auto_libMMAP_gf_DefenderMainAILoop_Trigger, false, false);
}

bool auto_libMMAP_gf_DefenderMainAILoop_TriggerFunc (bool testConds, bool runActions) {
    unit lp_defenderUnit = auto_libMMAP_gf_DefenderMainAILoop_lp_defenderUnit;

    // Variable Declarations
    int lv_defendingTeam;
    region lv_defenseRegion;
    region lv_defenseLeashRegion;
    unit lv_flagUnit;
    const fixed lv_idleTimeMin_C = 4.0;
    const fixed lv_idleTimeMax_C = 8.0;
    unitgroup lv_enemiesInDefenseRegion;
    timer lv_idleTimer;
    point lv_leashTarget;
    unit lv_closestEnemy;
    unit lv_lastClosestEnemy;
    point lv_patrolTarget;
    bool lv_isRetakingFlag;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_defendingTeam = libMMAP_gf_TeamNumberOfUnit(lp_defenderUnit);
    lv_defenseRegion = libMMAP_gv_aVMechanics[lv_defendingTeam].lv_region[libMMAP_gv_currentCPIndex];
    lv_defenseLeashRegion = libMMAP_gv_aVMechanics[lv_defendingTeam].lv_defenderLeashRegion[libMMAP_gv_currentCPIndex];
    lv_enemiesInDefenseRegion = UnitGroupEmpty();
    lv_idleTimer = TimerCreate();

    // Implementation
    Wait(0.0625, c_timeGame);
    lv_flagUnit = libMMAP_gv_aVMechanics[lv_defendingTeam].lv_flag;
    UnitIssueOrder(lp_defenderUnit, OrderTargetingPoint(AbilityCommand("move", 0), RegionRandomPoint(lv_defenseRegion)), c_orderQueueReplace);
    TimerStart(lv_idleTimer, (lv_idleTimeMin_C + RandomFixed(0.0, (lv_idleTimeMax_C - lv_idleTimeMin_C))), false, c_timeGame);
    TimerPause(lv_idleTimer, true);
    while ((UnitIsValid(lp_defenderUnit) == true)) {
        lv_enemiesInDefenseRegion = UnitGroupAlliance(UnitGetOwner(lp_defenderUnit), c_unitAllianceEnemy, lv_defenseRegion, UnitFilter((1 << c_targetFilterGround) | (1 << c_targetFilterVisible), 0, (1 << c_targetFilterMissile) | (1 << c_targetFilterItem) | (1 << c_targetFilterCloaked), (1 << (c_targetFilterStasis - 32)) | (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)) | (1 << (c_targetFilterInvulnerable - 32))), 0);
        if ((libNtve_gf_UnitInRegion(lp_defenderUnit, lv_defenseLeashRegion) == false)) {
            lv_lastClosestEnemy = null;
            lv_isRetakingFlag = false;
            if ((lv_leashTarget == null)) {
                lv_leashTarget = RegionRandomPoint(lv_defenseRegion);
                TextExpressionSetToken("Param/Expression/lib_MMAP_178C4779", "A", FixedToText(PointGetX(lv_leashTarget), 1));
                TextExpressionSetToken("Param/Expression/lib_MMAP_178C4779", "B", FixedToText(PointGetY(lv_leashTarget), 1));
                libMMAP_gf_DEBUG_WatchedDefenderLog(lp_defenderUnit, TextExpressionAssemble("Param/Expression/lib_MMAP_178C4779"));
            }

            UnitIssueOrder(lp_defenderUnit, OrderTargetingPoint(AbilityCommand("move", 0), lv_leashTarget), c_orderQueueReplace);
        }
        else if ((UnitGroupCount(lv_enemiesInDefenseRegion, c_unitCountAlive) > 0) && (UnitHasBehavior2(lp_defenderUnit, "MacGuffinDummy") == false)) {
            lv_leashTarget = null;
            lv_isRetakingFlag = false;
            lv_closestEnemy = UnitGroupClosestToPoint(lv_enemiesInDefenseRegion, UnitGetPosition(lp_defenderUnit));
            UnitIssueOrder(lp_defenderUnit, OrderTargetingUnit(AbilityCommand("attack", 0), lv_closestEnemy), c_orderQueueReplace);
            if ((lv_closestEnemy != lv_lastClosestEnemy)) {
                lv_lastClosestEnemy = lv_closestEnemy;
                TextExpressionSetToken("Param/Expression/lib_MMAP_0B9554B7", "A", UnitGetName(lv_closestEnemy));
                libMMAP_gf_DEBUG_WatchedDefenderLog(lp_defenderUnit, TextExpressionAssemble("Param/Expression/lib_MMAP_0B9554B7"));
            }

        }
        else if ((libMMAP_gv_aVMechanics[lv_defendingTeam].lv_flagIsCaptured == true) && (UnitHasBehavior2(lp_defenderUnit, "MacGuffinDummy") == false)) {
            lv_leashTarget = null;
            lv_lastClosestEnemy = null;
            UnitIssueOrder(lp_defenderUnit, OrderTargetingUnit(AbilityCommand("CaptureMacGuffin", 0), lv_flagUnit), c_orderQueueReplace);
            if ((lv_isRetakingFlag == false)) {
                libMMAP_gf_DEBUG_WatchedDefenderLog(lp_defenderUnit, StringExternal("Param/Value/lib_MMAP_A8BA7A28"));
                lv_isRetakingFlag = true;
            }

        }
        else if ((OrderGetAbilityCommand(UnitOrder(lp_defenderUnit, 0)) == null) && (TimerGetRemaining(lv_idleTimer) <= 0.0)) {
            lv_leashTarget = null;
            lv_lastClosestEnemy = null;
            lv_isRetakingFlag = false;
            lv_patrolTarget = RegionRandomPoint(lv_defenseRegion);
            UnitIssueOrder(lp_defenderUnit, OrderTargetingPoint(AbilityCommand("attack", 0), lv_patrolTarget), c_orderQueueReplace);
            TextExpressionSetToken("Param/Expression/lib_MMAP_6B435B15", "A", FixedToText(PointGetX(lv_patrolTarget), 1));
            TextExpressionSetToken("Param/Expression/lib_MMAP_6B435B15", "B", FixedToText(PointGetY(lv_patrolTarget), 1));
            libMMAP_gf_DEBUG_WatchedDefenderLog(lp_defenderUnit, TextExpressionAssemble("Param/Expression/lib_MMAP_6B435B15"));
            TimerStart(lv_idleTimer, (lv_idleTimeMin_C + RandomFixed(0.0, (lv_idleTimeMax_C - lv_idleTimeMin_C))), false, c_timeGame);
            TimerPause(lv_idleTimer, true);
        }
        else if ((OrderGetAbilityCommand(UnitOrder(lp_defenderUnit, 0)) == null) && (TimerIsPaused(lv_idleTimer) == true)) {
            lv_leashTarget = null;
            lv_lastClosestEnemy = null;
            lv_isRetakingFlag = false;
            TimerPause(lv_idleTimer, false);
            TextExpressionSetToken("Param/Expression/lib_MMAP_7D5D3EFA", "A", FixedToText(TimerGetRemaining(lv_idleTimer), 1));
            libMMAP_gf_DEBUG_WatchedDefenderLog(lp_defenderUnit, TextExpressionAssemble("Param/Expression/lib_MMAP_7D5D3EFA"));
        }
        Wait(libMMAP_gv_defenderAIUpdateRate_C, c_timeGame);
    }
    return true;
}

void libMMAP_gf_DEBUG_WatchedDefenderLog (unit lp_defenderUnit, text lp_logText) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_defenderUnit == libMMAP_gv_dEBUG_WatchedDefender)) {
        TriggerDebugOutput(1, lp_logText, true);
    }

}

bool libMMAP_gf_UnitIsCaptureFlag (unit lp_unit) {
    // Automatic Variable Declarations
    // Implementation
    return ((lp_unit == libMMAP_gv_aVMechanics[libGame_gv_teamOrderIndex_C].lv_flag) || (lp_unit == libMMAP_gv_aVMechanics[libGame_gv_teamChaosIndex_C].lv_flag));
}

void libMMAP_gf_EnableDisableCaptureFlag (int lp_team, bool lp_enableOrDisable) {
    // Variable Declarations
    int lv_i;
    int lv_enemyTeam;

    // Automatic Variable Declarations
    unitgroup autoF5CBDF82_g;
    int autoF5CBDF82_u;
    unit autoF5CBDF82_var;
    int autoD954F2E0_ae;
    const int autoD954F2E0_ai = 1;
    const int autoC1232AD1_ae = libMMAP_gv_defenderCountMaximum_C;
    const int autoC1232AD1_ai = 1;
    int autoD4B808A1_ae;
    const int autoD4B808A1_ai = 1;

    // Variable Initialization
    lv_enemyTeam = libGame_gf_EnemyTeam(lp_team);

    // Implementation
    libMMAP_gv_aVMechanics[lp_team].lv_flagIsCaptured = false;
    if ((lp_enableOrDisable == true)) {
        libMMAP_gv_capturingPlayerID[lp_team] = 0;
        libMMAP_gv_aVMechanics[lp_team].lv_victoryProgress = libMMAP_gv_captureFlagVictoryTimeGoal;
        libMMAP_gv_aVMechanics[lp_team].lv_victoryProgressPercent = 0.0;
        libMMAP_gv_currentTeamLeader = libCore_gv_cOMPUTER_Neutral;
        libNtve_gf_CreateUnitsAtPoint2(1, "CapturedSoldier", c_unitCreateIgnorePlacement, libMMAP_gf_NoVisionComputerPlayerInTeam(lp_team), libMMAP_gv_aVMechanics[lv_enemyTeam].lv_flagSpawnPoint[libMMAP_gv_currentCPIndex], null);
        libMMAP_gv_aVMechanics[lv_enemyTeam].lv_flag = UnitLastCreated();
        AddUnitOfInterest(libMMAP_gv_aVMechanics[lv_enemyTeam].lv_flag, 500.0, 0.0, "CaptureFlag", libAIAI_gf_ConvertIntegertoGoalTeam(lp_team), 0);
        libMMAP_gf_UnitNotTargetableForTeam(libMMAP_gv_aVMechanics[lv_enemyTeam].lv_flag, lv_enemyTeam);
        libNtve_gf_CreateUnitsWithDefaultFacing(1, "AVMinimapIcon", c_unitCreateIgnorePlacement, libMMAP_gf_NoVisionComputerPlayerInTeam(lp_team), libMMAP_gv_aVMechanics[lp_team].lv_flagSpawnPoint[libMMAP_gv_currentCPIndex], null);
        libMMAP_gv_aVMechanics[lp_team].lv_flagMinimapIcon = UnitLastCreated();
        if ((lp_team == libGame_gv_teamOrderIndex_C)) {
            ActorSend(libNtve_gf_MainActorofUnit(libMMAP_gv_aVMechanics[lp_team].lv_flagMinimapIcon), "MinimapTooltip Alterac/CaptureCage/Alliance/Tooltip");
        }
        else {
            ActorSend(libNtve_gf_MainActorofUnit(libMMAP_gv_aVMechanics[lp_team].lv_flagMinimapIcon), "MinimapTooltip Alterac/CaptureCage/Horde/Tooltip");
        }
        UnitGroupAdd(libMMAP_gv_aVMechanics[lp_team].lv_eventUnitGroup, libMMAP_gv_aVMechanics[lp_team].lv_flagMinimapIcon);
        libNtve_gf_CreateUnitsWithDefaultFacing(1, "LockDummyUnit", c_unitCreateIgnorePlacement, libMMAP_gf_NoVisionComputerPlayerInTeam(lp_team), libMMAP_gv_aVMechanics[lp_team].lv_flagDummyLockUnitSpawnPoint[libMMAP_gv_currentCPIndex], null);
        libMMAP_gv_aVMechanics[lv_enemyTeam].lv_flagDummyLockUnit = UnitLastCreated();
        UnitBehaviorAdd(libMMAP_gv_aVMechanics[lv_enemyTeam].lv_flagDummyLockUnit, "MacguffinActivated", libMMAP_gv_aVMechanics[lv_enemyTeam].lv_flagDummyLockUnit, 1);
        UnitGroupAdd(libMMAP_gv_aVMechanics[lv_enemyTeam].lv_eventUnitGroup, libMMAP_gv_aVMechanics[lv_enemyTeam].lv_flagDummyLockUnit);
        libNtve_gf_SendActorMessageToUnit(libMMAP_gv_aVMechanics[lv_enemyTeam].lv_flagMinimapIcon, "Signal Default");
        libMMAP_gf_SpawnAllDefendersImmediately(lp_team);
        ActorSend(libMMAP_gv_aVMechanics[lp_team].lv_flagCaptureDoodadActor[libMMAP_gv_currentCPIndex], "Signal DefaultOn");
        ActorSend(libMMAP_gv_aVMechanics[lp_team].lv_flagCaptureDoodadActor[libMMAP_gv_currentCPIndex], "SetPlayerId "+IntToString((libGame_gf_ComputerPlayerInTeam(lp_team))));
        UnitSetOwner(libMMAP_gv_aVMechanics[lp_team].lv_cageUnit[libMMAP_gv_currentCPIndex], libMMAP_gf_NoVisionComputerPlayerInTeam(lp_team), true);
        libMMAP_gf_AttachHelpButtonToUnit(libMMAP_gv_aVMechanics[lv_enemyTeam].lv_flag, lp_team, StringExternal("Param/Value/lib_MMAP_CD91F8E7"), StringExternal("Param/Value/lib_MMAP_C514A158"));
        libMMAP_gf_TeamDoesDoesNotCaptureFlag(lp_team, lv_enemyTeam, false, false);
        libMMAP_gf_UpdateCaptureProgressBarUIForTeam(lp_team, lv_enemyTeam);
    }
    else {
        libMMAP_gv_aVMechanics[lp_team].lv_respawnDefenders = false;
        TriggerEnable(libMMAP_gv_aVMechanics[lp_team].lv_defenderDeathTracker, false);
        TriggerEnable(libMMAP_gv_aVMechanics[lp_team].lv_defenderSpawnTracker, false);
        autoF5CBDF82_g = libMMAP_gv_aVMechanics[lp_team].lv_eventUnitGroup;
        autoF5CBDF82_u = UnitGroupCount(autoF5CBDF82_g, c_unitCountAll);
        for (;; autoF5CBDF82_u -= 1) {
            autoF5CBDF82_var = UnitGroupUnitFromEnd(autoF5CBDF82_g, autoF5CBDF82_u);
            if (autoF5CBDF82_var == null) { break; }
            UnitRemove(autoF5CBDF82_var);
        }
        autoD954F2E0_ae = libMMAP_gv_defenderCount;
        lv_i = 1;
        for ( ; ( (autoD954F2E0_ai >= 0 && lv_i <= autoD954F2E0_ae) || (autoD954F2E0_ai < 0 && lv_i >= autoD954F2E0_ae) ) ; lv_i += autoD954F2E0_ai ) {
            libNtve_gf_StopTimer(libMMAP_gv_aVMechanics[lp_team].lv_defenderSpawnTimer[lv_i]);
        }
        lv_i = 1;
        for ( ; ( (autoC1232AD1_ai >= 0 && lv_i <= autoC1232AD1_ae) || (autoC1232AD1_ai < 0 && lv_i >= autoC1232AD1_ae) ) ; lv_i += autoC1232AD1_ai ) {
            ActorSend(libMMAP_gv_aVMechanics[lp_team].lv_defenderSpawnDoodadActor[libMMAP_gv_currentCPIndex][lv_i], "Signal StopWork");
            libMMAP_gv_aVMechanics[lp_team].lv_defenderSpawnPointInUse[lv_i] = false;
        }
        autoD4B808A1_ae = (libMMAP_ge_VictoryProgressCheckpoints__75Percent);
        lv_i = (libMMAP_ge_VictoryProgressCheckpoints__50Percent);
        for ( ; ( (autoD4B808A1_ai >= 0 && lv_i <= autoD4B808A1_ae) || (autoD4B808A1_ai < 0 && lv_i >= autoD4B808A1_ae) ) ; lv_i += autoD4B808A1_ai ) {
            libMMAP_gv_aVMechanics[lp_team].lv_victoryProgressCheckpoints[lv_i] = false;
        }
    }
}

trigger auto_libMMAP_gf_TeamCapturesFlag_Trigger = null;
int auto_libMMAP_gf_TeamCapturesFlag_lp_teamCapturingFlag;
int auto_libMMAP_gf_TeamCapturesFlag_lp_teamOfCapturedFlag;

void libMMAP_gf_TeamCapturesFlag (int lp_teamCapturingFlag, int lp_teamOfCapturedFlag) {
    auto_libMMAP_gf_TeamCapturesFlag_lp_teamCapturingFlag = lp_teamCapturingFlag;
    auto_libMMAP_gf_TeamCapturesFlag_lp_teamOfCapturedFlag = lp_teamOfCapturedFlag;

    if (auto_libMMAP_gf_TeamCapturesFlag_Trigger == null) {
        auto_libMMAP_gf_TeamCapturesFlag_Trigger = TriggerCreate("auto_libMMAP_gf_TeamCapturesFlag_TriggerFunc");
    }

    TriggerExecute(auto_libMMAP_gf_TeamCapturesFlag_Trigger, false, false);
}

bool auto_libMMAP_gf_TeamCapturesFlag_TriggerFunc (bool testConds, bool runActions) {
    int lp_teamCapturingFlag = auto_libMMAP_gf_TeamCapturesFlag_lp_teamCapturingFlag;
    int lp_teamOfCapturedFlag = auto_libMMAP_gf_TeamCapturesFlag_lp_teamOfCapturedFlag;

    // Variable Declarations
    int lv_computerPlayerInCapturingTeam;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_computerPlayerInCapturingTeam = libGame_gf_ComputerPlayerInTeam(lp_teamCapturingFlag);

    // Implementation
    libMMAP_gf_UpdateFlagUI(lp_teamCapturingFlag, lp_teamOfCapturedFlag);
    libMMAP_gf_TrickleSpawnFlagDefenders(lp_teamOfCapturedFlag);
    while ((libMMAP_gv_aVMechanics[lp_teamOfCapturedFlag].lv_flagIsCaptured == true)) {
        if ((libMMAP_gv_aVMechanics[lp_teamCapturingFlag].lv_victoryProgress > 0.0) && (UnitGroupCount(libMMAP_gv_aVMechanics[lp_teamOfCapturedFlag].lv_flagEnemyHeroesCapturingUnitGroup, c_unitCountAlive) <= 0)) {
            libMMAP_gv_aVMechanics[lp_teamCapturingFlag].lv_victoryProgress -= libMMAP_gv_captureFlagCheckPeriod_C;
            libMMAP_gv_aVMechanics[lp_teamCapturingFlag].lv_victoryProgressPercent = (100.0 - (100.0 * (libMMAP_gv_aVMechanics[lp_teamCapturingFlag].lv_victoryProgress / libMMAP_gv_captureFlagVictoryTimeGoal)));
            if ((libMMAP_gv_aVMechanics[lp_teamCapturingFlag].lv_victoryProgressPercent >= 50.0) && (libMMAP_gv_aVMechanics[lp_teamCapturingFlag].lv_victoryProgressCheckpoints[libMMAP_ge_VictoryProgressCheckpoints__50Percent] == false)) {
                libMMAP_gv_aVMechanics[lp_teamCapturingFlag].lv_victoryProgressCheckpoints[libMMAP_ge_VictoryProgressCheckpoints__50Percent] = true;
                UnitCreateEffectPoint(libMMAP_gv_aVMechanics[lp_teamOfCapturedFlag].lv_flag, "AVLaunchRegenGlobe", RegionRandomPoint(libMMAP_gv_aVMechanics[lp_teamOfCapturedFlag].lv_region[libMMAP_gv_currentCPIndex]));
                UnitBehaviorAdd(libMMAP_gv_aVMechanics[lp_teamOfCapturedFlag].lv_flag, "CageAttackSpeed", libMMAP_gv_aVMechanics[lp_teamOfCapturedFlag].lv_flag, 1);
            }

            if ((libMMAP_gv_aVMechanics[lp_teamCapturingFlag].lv_victoryProgressPercent >= 75.0) && (libMMAP_gv_aVMechanics[lp_teamCapturingFlag].lv_victoryProgressCheckpoints[libMMAP_ge_VictoryProgressCheckpoints__75Percent] == false)) {
                libMMAP_gv_aVMechanics[lp_teamCapturingFlag].lv_victoryProgressCheckpoints[libMMAP_ge_VictoryProgressCheckpoints__75Percent] = true;
                UnitBehaviorAdd(libMMAP_gv_aVMechanics[lp_teamOfCapturedFlag].lv_flag, "CageAttackSpeed", libMMAP_gv_aVMechanics[lp_teamOfCapturedFlag].lv_flag, 1);
            }

            if ((((libMMAP_gv_aVMechanics[lp_teamCapturingFlag].lv_victoryProgressPercent > libMMAP_gv_aVMechanics[libMMAP_gv_currentTeamLeader].lv_victoryProgressPercent) && (lp_teamCapturingFlag != libMMAP_gv_currentTeamLeader)) || (lp_teamCapturingFlag == libMMAP_gv_currentTeamLeader) || (libMMAP_gv_aVMechanics[lp_teamCapturingFlag].lv_flagIsCaptured == false))) {
                libMMAP_gf_UpdateTeamIconForTeamCurrentlyWinning(lp_teamCapturingFlag);
            }

            if ((libMMAP_gv_aVMechanics[lp_teamCapturingFlag].lv_victoryProgressPercent > libMMAP_gv_aVMechanics[libMMAP_gv_currentTeamLeader].lv_victoryProgressPercent) && (lp_teamCapturingFlag != libMMAP_gv_currentTeamLeader)) {
                libMMAP_gv_currentTeamLeader = lp_teamCapturingFlag;
                AddUnitOfInterest(libMMAP_gv_aVMechanics[lp_teamOfCapturedFlag].lv_flag, 500.0, 0.0, "RetakeFlag", libAIAI_gf_ConvertIntegertoGoalTeam(lp_teamOfCapturedFlag), 0);
            }

            libMMAP_gf_UpdateCaptureProgressBarUIForTeam(lp_teamCapturingFlag, lp_teamOfCapturedFlag);
        }
        else {
            if ((libMMAP_gv_aVMechanics[lp_teamCapturingFlag].lv_victoryProgress <= 0.0)) {
                UnitCreateEffectPoint(libMMAP_gv_aVMechanics[lp_teamOfCapturedFlag].lv_flag, "AVLaunchRegenGlobe", RegionRandomPoint(libMMAP_gv_aVMechanics[lp_teamOfCapturedFlag].lv_region[libMMAP_gv_currentCPIndex]));
                libMMAP_gf_TeamCompletesCaptureofFlag(lp_teamCapturingFlag, lp_teamOfCapturedFlag);
            }

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

void libMMAP_gf_TeamCompletesCaptureofFlag (int lp_winningTeam, int lp_losingTeam) {
    // Variable Declarations
    int lv_i;

    // Automatic Variable Declarations
    const int auto88432A45_ae = libCore_gv_bALMaxTeams;
    const int auto88432A45_ai = 1;

    // Variable Initialization

    // Implementation
    TriggerEnable(libMMAP_gt_PlayerCompletesChannelMacguffin, false);
    TriggerEnable(libMMAP_gt_PlayerStartsChannelMacguffin, false);
    TriggerEnable(libMMAP_gt_PlayerInterruptsChannelMacguffin, false);
    if ((lp_winningTeam == libGame_gv_teamOrderIndex_C)) {
        libMMAP_gf_AllianceWinsObjective();
    }
    else {
        libMMAP_gf_HordeWinsObjective();
    }
    libMMAP_gf_FlagVictorySequence(lp_winningTeam, lp_losingTeam);
    libMMAP_gf_UpdateVictoriousTeamIcon(lp_winningTeam);
    DialogControlSendAnimationEvent(libMMAP_gv_aVUI.lv_victoryProgressBar[libMMAP_ge_AVUIProgressBars_Bottom], libGame_gf_PlayersOnTeamHeroes(lp_winningTeam, false), "Hide");
    DialogControlSendAnimationEvent(libMMAP_gv_aVUI.lv_victoryProgressBar[libMMAP_ge_AVUIProgressBars_Top], libGame_gf_PlayersOnTeamHeroes(lp_losingTeam, false), "Hide");
    DialogControlSendAnimationEvent(libMMAP_gv_aVUI.lv_mMContainer, PlayerGroupAll(), "MechanicDone");
    DialogControlSetAnimationState(libMMAP_gv_aVUI.lv_mMContainer, PlayerGroupAll(), "TeamWins", IntToString(lp_winningTeam));
    libMMAP_gv_aVMechanics[lp_winningTeam].lv_eventsWon += 1;
    if ((libMMAP_gv_captureFlagVictoryTimeGoal < libMMAP_gv_captureFlagVictoryTimeGoalMax_C)) {
        libMMAP_gv_captureFlagVictoryTimeGoal += libMMAP_gv_captureFlagVictoryTimeGoalTimeIncrement_C;
        libMMAP_gv_captureFlagVictoryTimeGoal = MinF(libMMAP_gv_captureFlagVictoryTimeGoal, libMMAP_gv_captureFlagVictoryTimeGoalMax_C);
    }

    if ((libMMAP_gv_defenderCount != libMMAP_gv_defenderCountMaximum_C)) {
        libMMAP_gv_defenderCount += libMMAP_gv_defenderIncrementCount_C;
    }

    lv_i = 1;
    for ( ; ( (auto88432A45_ai >= 0 && lv_i <= auto88432A45_ae) || (auto88432A45_ai < 0 && lv_i >= auto88432A45_ae) ) ; lv_i += auto88432A45_ai ) {
        libMMAP_gf_EnableDisableCaptureFlag(lv_i, false);
    }
    libMapM_gf_JungleStartHibernateCamps();
    libMMAP_gf_PreparetoSpawnCavalry(lp_winningTeam);
}

trigger auto_libMMAP_gf_FlagVictorySequence_Trigger = null;
int auto_libMMAP_gf_FlagVictorySequence_lp_winningTeam;
int auto_libMMAP_gf_FlagVictorySequence_lp_losingTeam;

void libMMAP_gf_FlagVictorySequence (int lp_winningTeam, int lp_losingTeam) {
    auto_libMMAP_gf_FlagVictorySequence_lp_winningTeam = lp_winningTeam;
    auto_libMMAP_gf_FlagVictorySequence_lp_losingTeam = lp_losingTeam;

    if (auto_libMMAP_gf_FlagVictorySequence_Trigger == null) {
        auto_libMMAP_gf_FlagVictorySequence_Trigger = TriggerCreate("auto_libMMAP_gf_FlagVictorySequence_TriggerFunc");
    }

    TriggerExecute(auto_libMMAP_gf_FlagVictorySequence_Trigger, false, false);
}

bool auto_libMMAP_gf_FlagVictorySequence_TriggerFunc (bool testConds, bool runActions) {
    int lp_winningTeam = auto_libMMAP_gf_FlagVictorySequence_lp_winningTeam;
    int lp_losingTeam = auto_libMMAP_gf_FlagVictorySequence_lp_losingTeam;

    // Variable Declarations
    int lv_i;

    // Automatic Variable Declarations
    const int autoBE406EDD_ae = libGame_gv_teamChaosIndex_C;
    const int autoBE406EDD_ai = 1;

    // Variable Initialization

    // Implementation
    lv_i = libGame_gv_teamOrderIndex_C;
    for ( ; ( (autoBE406EDD_ai >= 0 && lv_i <= autoBE406EDD_ae) || (autoBE406EDD_ai < 0 && lv_i >= autoBE406EDD_ae) ) ; lv_i += autoBE406EDD_ai ) {
        TextTagDestroy(libMMAP_gv_aVUI.lv_cageTextTag[lv_i][libGame_gv_teamOrderIndex_C]);
        TextTagDestroy(libMMAP_gv_aVUI.lv_cageTextTag[lv_i][libGame_gv_teamChaosIndex_C]);
        UnitBehaviorRemove(libMMAP_gv_aVMechanics[lv_i].lv_flag, "MacguffinActivated", 1);
        UnitBehaviorRemove(libMMAP_gv_aVMechanics[lv_i].lv_flag, "CageIsCaptured", 1);
        libMMAP_gf_UnitNotTargetableForTeam(libMMAP_gv_aVMechanics[lv_i].lv_flag, lv_i);
    }
    ActorSend(libMMAP_gv_aVMechanics[lp_winningTeam].lv_flagCaptureDoodadActor[libMMAP_gv_currentCPIndex], "Signal Defeat");
    ActorSend(libMMAP_gv_aVMechanics[lp_losingTeam].lv_flagCaptureDoodadActor[libMMAP_gv_currentCPIndex], "Signal Captured");
    libNtve_gf_SendActorMessageToUnit(libMMAP_gv_aVMechanics[lp_winningTeam].lv_flag, "Signal Defeat");
    libNtve_gf_SendActorMessageToUnit(libMMAP_gv_aVMechanics[lp_losingTeam].lv_flag, "Signal Victory");
    Wait(1.9375, c_timeGame);
    UnitKill(libMMAP_gv_aVMechanics[lp_winningTeam].lv_flag);
    Wait(1.5, c_timeGame);
    UnitKill(libMMAP_gv_aVMechanics[lp_losingTeam].lv_flag);
    libGame_gf_DropLootBannerinSconce(libMMAP_gv_aVMechanics[lp_losingTeam].lv_cageBannerSconceUnit[libMMAP_gv_currentCPIndex], libGame_gv_players[libMMAP_gv_capturingPlayerID[lp_winningTeam]].lv_lootContent.lv_loot_Banner.lv_bannerID, libMMAP_gv_capturingPlayerID[lp_winningTeam], true);
    return true;
}

void libMMAP_gf_UnitNotTargetableForTeam (unit lp_unit, int lp_team) {
    // Automatic Variable Declarations
    playergroup auto436D5018_g;
    int auto436D5018_var;
    playergroup autoE77E92A2_g;
    int autoE77E92A2_var;

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

    auto436D5018_g = libGame_gf_PlayersOnTeamHeroes(lp_team, true);
    auto436D5018_var = -1;
    while (true) {
        	auto436D5018_var = PlayerGroupNextPlayer(auto436D5018_g, auto436D5018_var);
        	if (auto436D5018_var<0) { break; }
        	UnitSetStateForPlayer(lp_unit, c_unitStateTargetable, auto436D5018_var, false);
    }
    autoE77E92A2_g = libGame_gf_PlayersOnTeamHeroes(libGame_gf_EnemyTeam(lp_team), true);
    autoE77E92A2_var = -1;
    while (true) {
        	autoE77E92A2_var = PlayerGroupNextPlayer(autoE77E92A2_g, autoE77E92A2_var);
        	if (autoE77E92A2_var<0) { break; }
        	UnitSetStateForPlayer(lp_unit, c_unitStateTargetable, autoE77E92A2_var, true);
    }
}

void libMMAP_gf_TeamsRewardUnitDies (int lp_team) {
    // Automatic Variable Declarations
    // Implementation
    if ((UnitGroupCount(libMMAP_gv_aVMechanics[lp_team].lv_cavalryUnitGroup, c_unitCountAlive) <= 0)) {
        libMMAP_gf_EventRewardFinishedAllEventUnitsDied(lp_team);
    }

}

trigger auto_libMMAP_gf_PreparetoSpawnCavalry_Trigger = null;
int auto_libMMAP_gf_PreparetoSpawnCavalry_lp_team;

void libMMAP_gf_PreparetoSpawnCavalry (int lp_team) {
    auto_libMMAP_gf_PreparetoSpawnCavalry_lp_team = lp_team;

    if (auto_libMMAP_gf_PreparetoSpawnCavalry_Trigger == null) {
        auto_libMMAP_gf_PreparetoSpawnCavalry_Trigger = TriggerCreate("auto_libMMAP_gf_PreparetoSpawnCavalry_TriggerFunc");
    }

    TriggerExecute(auto_libMMAP_gf_PreparetoSpawnCavalry_Trigger, false, false);
}

bool auto_libMMAP_gf_PreparetoSpawnCavalry_TriggerFunc (bool testConds, bool runActions) {
    int lp_team = auto_libMMAP_gf_PreparetoSpawnCavalry_lp_team;

    // Variable Declarations
    int lv_i;

    // Automatic Variable Declarations
    const int autoA6B04B11_ae = libMMAP_gv_aVLaneCount_C;
    const int autoA6B04B11_ai = 1;

    // Variable Initialization

    // Implementation
    SoundPlayForPlayer(libMMAP_gv_aVSounds.lv_aVTeamSpecificSounds[lp_team].lv_cavalrySpawnWarning, c_maxPlayers, PlayerGroupAll(), 100.0, 0.0);
    libSond_gf_SoundtrackApplyNewDefaultSoundtrackForPlayerGroup("AVEventSoundtrack", PlayerGroupAll());
    TriggerEnable(libMMAP_gv_aVMechanics[lp_team].lv_cavalrySpawnTrigger, true);
    TimerStart(libMMAP_gv_aVMechanics[lp_team].lv_cavalrySpawnTimer, libMMAP_gv_mapMechanicSpawnDelay_C, false, c_timeGame);
    lv_i = 1;
    for ( ; ( (autoA6B04B11_ai >= 0 && lv_i <= autoA6B04B11_ae) || (autoA6B04B11_ai < 0 && lv_i >= autoA6B04B11_ae) ) ; lv_i += autoA6B04B11_ai ) {
        libNtve_gf_CreateActorWithPointFacing(libMMAP_gv_aVMechanics[lp_team].lv_cavalryBirthActorType, libMMAP_gv_aVMechanics[lp_team].lv_cavalrySpawnPoint[lv_i]);
        libMMAP_gv_aVMechanics[lp_team].lv_cavalryBirthActor[lv_i] = libNtve_gf_ActorLastCreated();
        ActorSend(libMMAP_gv_aVMechanics[lp_team].lv_cavalryBirthActor[lv_i], "TimerSet "+(IntToString(libMMAP_gv_mapMechanicSpawnDelay_C - 2))+" BirthTimer");
    }
    return true;
}

trigger auto_libMMAP_gf_SpawnCavalryForTeam_Trigger = null;
int auto_libMMAP_gf_SpawnCavalryForTeam_lp_team;

void libMMAP_gf_SpawnCavalryForTeam (int lp_team) {
    auto_libMMAP_gf_SpawnCavalryForTeam_lp_team = lp_team;

    if (auto_libMMAP_gf_SpawnCavalryForTeam_Trigger == null) {
        auto_libMMAP_gf_SpawnCavalryForTeam_Trigger = TriggerCreate("auto_libMMAP_gf_SpawnCavalryForTeam_TriggerFunc");
    }

    TriggerExecute(auto_libMMAP_gf_SpawnCavalryForTeam_Trigger, false, false);
}

bool auto_libMMAP_gf_SpawnCavalryForTeam_TriggerFunc (bool testConds, bool runActions) {
    int lp_team = auto_libMMAP_gf_SpawnCavalryForTeam_lp_team;

    // Variable Declarations
    int lv_i;
    int lv_computerPlayer;
    int lv_enemyTeam;

    // Automatic Variable Declarations
    const int autoCF69F4A8_ae = libMMAP_gv_aVLaneCount_C;
    const int autoCF69F4A8_ai = 1;

    // Variable Initialization
    lv_computerPlayer = libGame_gf_ComputerPlayerInTeam(lp_team);
    lv_enemyTeam = libGame_gf_EnemyTeam(lp_team);

    // Implementation
    libMMAP_gv_mapMechanicRewardActive = true;
    TriggerEnable(libMMAP_gv_aVMechanics[lp_team].lv_cavalrySpawnTrigger, false);
    TriggerEnable(libMMAP_gv_aVMechanics[lp_team].lv_cavalryDeathTracker, true);
    if ((lp_team == libGame_gv_teamOrderIndex_C)) {
        libMMAP_gf_AllianceCavalryCharges();
    }
    else {
        libMMAP_gf_HordeCavalryCharges();
    }
    lv_i = 1;
    for ( ; ( (autoCF69F4A8_ai >= 0 && lv_i <= autoCF69F4A8_ae) || (autoCF69F4A8_ai < 0 && lv_i >= autoCF69F4A8_ae) ) ; lv_i += autoCF69F4A8_ai ) {
        libGame_gf_CalculateSpawnedMinionGoalPoints(lv_computerPlayer, libMMAP_gv_aVMechanics[lp_team].lv_cavalrySpawnPoint[lv_i]);
        libNtve_gf_CreateUnitsAtPoint2(1, libMMAP_gv_aVMechanics[lp_team].lv_cavalryUnitType, 0, lv_computerPlayer, libMMAP_gv_aVMechanics[lp_team].lv_cavalrySpawnPoint[lv_i], null);
        libMMAP_gv_aVMechanics[lp_team].lv_cavalryUnit[lv_i] = UnitLastCreated();
        UnitGroupAdd(libMMAP_gv_aVMechanics[lp_team].lv_cavalryUnitGroup, libMMAP_gv_aVMechanics[lp_team].lv_cavalryUnit[lv_i]);
        libGame_gf_UpdateScalingForUnit(libMMAP_gv_aVMechanics[lp_team].lv_cavalryUnit[lv_i], libGame_gv_scalingTicks, 0);
        libAIAI_gf_MinionAIStartMinionAI(-1, libMMAP_gv_aVMechanics[lp_team].lv_cavalryUnit[lv_i], libGame_gv_spawnedMinionLane, libGame_gv_spawnedMinionFirstWaypointIndex, true, false, false, 0, false);
        libCore_gf_CreateMinimapPingStormWithPlayerId(PlayerGroupAll(), "CavalrySpawned", libMMAP_gv_aVMechanics[lp_team].lv_cavalrySpawnPoint[lv_i], ColorWithAlpha(0,0,0,0), 5.0, lv_computerPlayer);
        PingSetUnit(PingLastCreated(), libMMAP_gv_aVMechanics[lp_team].lv_cavalryUnit[lv_i]);
        libNtve_gf_SetDialogItemUnit(libMMAP_gv_aVUI.lv_mapMechanicHealthBar[lv_i], libMMAP_gv_aVMechanics[lp_team].lv_cavalryUnit[lv_i], PlayerGroupAll());
        DialogControlSetVisible(libMMAP_gv_aVUI.lv_mapMechanicHealthBar[lv_i], PlayerGroupAll(), true);
    }
    DialogControlSendAnimationEvent(libMMAP_gv_aVUI.lv_mMContainer, PlayerGroupAll(), "CavalryActive");
    DialogControlSetVisible(libMMAP_gv_aVUI.lv_teamWinningIcon_Glow[lp_team], PlayerGroupAll(), true);
    SoundPlayForPlayer(libMMAP_gv_aVSounds.lv_aVTeamSpecificSounds[lp_team].lv_cavalrySpawn, c_maxPlayers, PlayerGroupAll(), 100.0, 0.0);
    return true;
}

trigger auto_libMMAP_gf_EventRewardFinishedAllEventUnitsDied_Trigger = null;
int auto_libMMAP_gf_EventRewardFinishedAllEventUnitsDied_lp_team;

void libMMAP_gf_EventRewardFinishedAllEventUnitsDied (int lp_team) {
    auto_libMMAP_gf_EventRewardFinishedAllEventUnitsDied_lp_team = lp_team;

    if (auto_libMMAP_gf_EventRewardFinishedAllEventUnitsDied_Trigger == null) {
        auto_libMMAP_gf_EventRewardFinishedAllEventUnitsDied_Trigger = TriggerCreate("auto_libMMAP_gf_EventRewardFinishedAllEventUnitsDied_TriggerFunc");
    }

    TriggerExecute(auto_libMMAP_gf_EventRewardFinishedAllEventUnitsDied_Trigger, false, false);
}

bool auto_libMMAP_gf_EventRewardFinishedAllEventUnitsDied_TriggerFunc (bool testConds, bool runActions) {
    int lp_team = auto_libMMAP_gf_EventRewardFinishedAllEventUnitsDied_lp_team;

    // Automatic Variable Declarations
    // Implementation
    TriggerEnable(libMMAP_gv_aVMechanics[lp_team].lv_cavalryDeathTracker, false);
    libMMAP_gv_currentCPIndex = (3 - libMMAP_gv_currentCPIndex);
    libMMAP_gv_mapMechanicRewardActive = false;
    libMapM_gf_JungleStopHibernateCamps();
    DialogControlSetVisible(libMMAP_gv_aVUI.lv_teamWinningIcon_Glow[lp_team], PlayerGroupAll(), false);
    DialogControlSendAnimationEvent(libMMAP_gv_aVUI.lv_mMContainer, PlayerGroupAll(), "CavalrySlain");
    DialogControlSendAnimationEvent(libMMAP_gv_aVUI.lv_teamWinningIcon[lp_team], PlayerGroupAll(), "Defeated");
    libMMAP_gf_UpdateNotificationCountdownLabel(StringExternal("Param/Value/lib_MMAP_9E9B64E8"), StringExternal("Param/Value/lib_MMAP_313D78D3"), lp_team, null);
    libSond_gf_SoundtrackPlayMapSoundtrackAsDefaultSoundtrackForAllPlayers();
    if ((lp_team == libGame_gv_teamOrderIndex_C)) {
        libMMAP_gf_AllianceCavalrySlain();
    }
    else {
        libMMAP_gf_HordeCavalrySlain();
    }
    SoundPlayForPlayer(SoundLink("UI_Game_AlteracPass_EventEnd", -1), c_maxPlayers, PlayerGroupAll(), 100.0, 0.0);
    libMMAP_gf_RestartEventTimers();
    Wait(5.0, c_timeGame);
    DialogControlSetAnimationState(libMMAP_gv_aVUI.lv_mMContainer, PlayerGroupAll(), "TeamWins", IntToString(libCore_gv_cOMPUTER_Neutral));
    DialogControlSendAnimationEvent(libMMAP_gv_aVUI.lv_mMContainer, PlayerGroupAll(), "Hide");
    return true;
}

void libMMAP_gf_HookUpUI () {
    int init_i;

    // Variable Declarations
    int lv_currentPanel;
    int[4] lv_dialogIterm;
    int lv_i;

    // Automatic Variable Declarations
    const int auto3661B6FC_ae = libMMAP_gv_notificationCountMax_C;
    const int auto3661B6FC_ai = 1;
    int autoC349B499_ae;
    const int auto8CF23E7F_ae = libGame_gv_teamChaosIndex_C;
    const int auto8CF23E7F_ai = 1;

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

    // Implementation
    DialogControlCreateInPanelFromTemplate(libUIUI_gv_mapMechanicsPanel.lv_mainPanel, c_triggerControlTypePanel, "AlteracMechanics/AlteracMechanicsPanel");
    libMMAP_gv_aVUI.lv_mainPanel = DialogControlLastCreated();
    lv_i = 1;
    for ( ; ( (auto3661B6FC_ai >= 0 && lv_i <= auto3661B6FC_ae) || (auto3661B6FC_ai < 0 && lv_i >= auto3661B6FC_ae) ) ; lv_i += auto3661B6FC_ai ) {
        DialogControlHookup(libMMAP_gv_aVUI.lv_mainPanel, c_triggerControlTypePanel, "NotificationFrame"+(IntToString(lv_i)));
        libMMAP_gv_aVUI.lv_notificationFrame[lv_i] = DialogControlLastCreated();
        DialogControlHookup(libMMAP_gv_aVUI.lv_notificationFrame[lv_i], c_triggerControlTypeLabel, "NotificationLabel");
        libMMAP_gv_aVUI.lv_notificationLabel[lv_i] = DialogControlLastCreated();
    }
    DialogControlHookup(libMMAP_gv_aVUI.lv_mainPanel, c_triggerControlTypePanel, "AVMechanicContainer");
    libMMAP_gv_aVUI.lv_mMContainer = DialogControlLastCreated();
    DialogControlHookup(libMMAP_gv_aVUI.lv_mMContainer, c_triggerControlTypePanel, "MapMechanicStatusMasker");
    lv_currentPanel += 1;
    lv_dialogIterm[lv_currentPanel] = DialogControlLastCreated();
    DialogControlHookup(lv_dialogIterm[lv_currentPanel], c_triggerControlTypePanel, "MapMechanicStatus");
    lv_currentPanel += 1;
    lv_dialogIterm[lv_currentPanel] = DialogControlLastCreated();
    autoC349B499_ae = libMMAP_gv_aVLaneCount_C;
    lv_i = 1;
    for ( ; lv_i <= autoC349B499_ae ; lv_i += 1 ) {
        DialogControlHookup(lv_dialogIterm[lv_currentPanel], c_triggerControlTypeUnitStatus, "CavalryHealthBarAnchorFrame"+(IntToString(lv_i))+"/CavalryUnitStatusFrame");
        libMMAP_gv_aVUI.lv_mapMechanicHealthBar[lv_i] = DialogControlLastCreated();
    }
    lv_currentPanel -= 2;
    DialogControlHookup(libMMAP_gv_aVUI.lv_mMContainer, c_triggerControlTypeLabel, "NotificationLabel");
    libMMAP_gv_aVUI.lv_mechanicLabel = DialogControlLastCreated();
    lv_i = libCore_gv_cOMPUTER_Neutral;
    for ( ; ( (auto8CF23E7F_ai >= 0 && lv_i <= auto8CF23E7F_ae) || (auto8CF23E7F_ai < 0 && lv_i >= auto8CF23E7F_ae) ) ; lv_i += auto8CF23E7F_ai ) {
        DialogControlHookup(libMMAP_gv_aVUI.lv_mMContainer, c_triggerControlTypePanel, "Team"+(IntToString(lv_i))+"Icon");
        libMMAP_gv_aVUI.lv_teamWinningIcon[lv_i] = DialogControlLastCreated();
    }
    DialogControlHookup(libMMAP_gv_aVUI.lv_mMContainer, c_triggerControlTypePanel, "ProgressBarMasker/ProgressBarsContainer");
    lv_currentPanel += 1;
    lv_dialogIterm[lv_currentPanel] = DialogControlLastCreated();
    DialogControlHookup(lv_dialogIterm[lv_currentPanel], c_triggerControlTypePanel, "TopProgressBar");
    lv_currentPanel += 1;
    lv_dialogIterm[lv_currentPanel] = DialogControlLastCreated();
    DialogControlHookup(lv_dialogIterm[lv_currentPanel], c_triggerControlTypeProgressBar, "ProgressBar");
    libMMAP_gv_aVUI.lv_victoryProgressBar[libMMAP_ge_AVUIProgressBars_Top] = DialogControlLastCreated();
    DialogControlHookup(libMMAP_gv_aVUI.lv_victoryProgressBar[libMMAP_ge_AVUIProgressBars_Top], c_triggerControlTypePanel, "FillImageContainer");
    lv_currentPanel += 1;
    lv_dialogIterm[lv_currentPanel] = DialogControlLastCreated();
    DialogControlHookup(lv_dialogIterm[lv_currentPanel], c_triggerControlTypeLabel, "ProgressLabel");
    libMMAP_gv_aVUI.lv_progressBarLabel[libMMAP_ge_AVUIProgressBars_Top] = DialogControlLastCreated();
    lv_currentPanel -= 2;
    DialogControlHookup(lv_dialogIterm[lv_currentPanel], c_triggerControlTypePanel, "BottomProgressBar");
    lv_currentPanel += 1;
    lv_dialogIterm[lv_currentPanel] = DialogControlLastCreated();
    DialogControlHookup(lv_dialogIterm[lv_currentPanel], c_triggerControlTypeProgressBar, "ProgressBar");
    libMMAP_gv_aVUI.lv_victoryProgressBar[libMMAP_ge_AVUIProgressBars_Bottom] = DialogControlLastCreated();
    DialogControlHookup(libMMAP_gv_aVUI.lv_victoryProgressBar[libMMAP_ge_AVUIProgressBars_Bottom], c_triggerControlTypePanel, "FillImageContainer");
    lv_currentPanel += 1;
    lv_dialogIterm[lv_currentPanel] = DialogControlLastCreated();
    DialogControlHookup(lv_dialogIterm[lv_currentPanel], c_triggerControlTypeLabel, "ProgressLabel");
    libMMAP_gv_aVUI.lv_progressBarLabel[libMMAP_ge_AVUIProgressBars_Bottom] = DialogControlLastCreated();
    DialogControlHookup(libMMAP_gv_aVUI.lv_teamWinningIcon[0], c_triggerControlTypeImage, "IconContainer/AllianceImage_DarkRed");
    DialogControlFadeTransparency(DialogControlLastCreated(), libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamOrderIndex_C, false), 0.0, 100.0);
    DialogControlHookup(libMMAP_gv_aVUI.lv_teamWinningIcon[0], c_triggerControlTypeImage, "IconContainer/AllianceImage_DarkBlue");
    DialogControlFadeTransparency(DialogControlLastCreated(), libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamChaosIndex_C, false), 0.0, 100.0);
    DialogControlHookup(libMMAP_gv_aVUI.lv_teamWinningIcon[0], c_triggerControlTypeImage, "IconContainer/HordeImage_DarkRed");
    DialogControlFadeTransparency(DialogControlLastCreated(), libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamChaosIndex_C, false), 0.0, 100.0);
    DialogControlHookup(libMMAP_gv_aVUI.lv_teamWinningIcon[0], c_triggerControlTypeImage, "IconContainer/HordeImage_DarkBlue");
    DialogControlFadeTransparency(DialogControlLastCreated(), libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamOrderIndex_C, false), 0.0, 100.0);
    DialogControlHookup(libMMAP_gv_aVUI.lv_teamWinningIcon[libGame_gv_teamOrderIndex_C], c_triggerControlTypePanel, "IconContainer");
    DialogControlHookup(DialogControlLastCreated(), c_triggerControlTypeImage, "IconForeground_Glow");
    libMMAP_gv_aVUI.lv_teamWinningIcon_Glow[libGame_gv_teamOrderIndex_C] = DialogControlLastCreated();
    DialogControlHookup(libMMAP_gv_aVUI.lv_teamWinningIcon[libGame_gv_teamChaosIndex_C], c_triggerControlTypePanel, "IconContainer");
    DialogControlHookup(DialogControlLastCreated(), c_triggerControlTypeImage, "IconForeground_Glow");
    libMMAP_gv_aVUI.lv_teamWinningIcon_Glow[libGame_gv_teamChaosIndex_C] = DialogControlLastCreated();
}

void libMMAP_gf_UpdateCaptureProgressBarUIForTeam (int lp_team, int lp_enemyTeam) {
    // Variable Declarations
    text lv_text;
    playergroup lv_teamPlayerGroup;
    playergroup lv_enemyTeamPlayerGroup;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_teamPlayerGroup = libGame_gf_PlayersOnTeamHeroes(lp_team, false);
    lv_enemyTeamPlayerGroup = libGame_gf_PlayersOnTeamHeroes(lp_enemyTeam, false);

    // Implementation
    if ((lp_team == libGame_gv_teamOrderIndex_C)) {
        PlayerGroupAdd(lv_teamPlayerGroup, libCore_gv_cOMPUTER_Neutral);
    }
    else {
        PlayerGroupAdd(lv_enemyTeamPlayerGroup, libCore_gv_cOMPUTER_Neutral);
    }
    libNtve_gf_SetDialogItemCurrentValue(libMMAP_gv_aVUI.lv_victoryProgressBar[libMMAP_ge_AVUIProgressBars_Top], libMMAP_gv_aVMechanics[lp_team].lv_victoryProgressPercent, lv_teamPlayerGroup);
    libNtve_gf_SetDialogItemCurrentValue(libMMAP_gv_aVUI.lv_victoryProgressBar[libMMAP_ge_AVUIProgressBars_Bottom], libMMAP_gv_aVMechanics[lp_team].lv_victoryProgressPercent, lv_enemyTeamPlayerGroup);
    if ((libMMAP_gv_aVMechanics[lp_team].lv_victoryProgress >= 10.0)) {
        lv_text = FixedToText(libMMAP_gv_aVMechanics[lp_team].lv_victoryProgress, 0);
    }
    else {
        lv_text = FixedToText(libMMAP_gv_aVMechanics[lp_team].lv_victoryProgress, 1);
    }
    TextExpressionSetToken("Param/Expression/lib_MMAP_0B9B9A27", "A", lv_text);
    libNtve_gf_SetDialogItemText(libMMAP_gv_aVUI.lv_progressBarLabel[libMMAP_ge_AVUIProgressBars_Top], TextExpressionAssemble("Param/Expression/lib_MMAP_0B9B9A27"), lv_teamPlayerGroup);
    TextExpressionSetToken("Param/Expression/lib_MMAP_F22F0F30", "A", lv_text);
    libNtve_gf_SetDialogItemText(libMMAP_gv_aVUI.lv_progressBarLabel[libMMAP_ge_AVUIProgressBars_Bottom], TextExpressionAssemble("Param/Expression/lib_MMAP_F22F0F30"), lv_enemyTeamPlayerGroup);
}

void libMMAP_gf_UpdateTeamIconForTeamCurrentlyWinning (int lp_team) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_team != libCore_gv_cOMPUTER_Neutral)) {
        DialogControlSetAnimationState(libMMAP_gv_aVUI.lv_mMContainer, PlayerGroupAll(), "TeamWinningCage", IntToString(libGame_gf_ComputerPlayerInTeam(lp_team)));
    }
    else {
        DialogControlSetAnimationState(libMMAP_gv_aVUI.lv_mMContainer, PlayerGroupAll(), "TeamWinningCage", "00");
    }
}

void libMMAP_gf_UpdateVictoriousTeamIcon (int lp_team) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_team != libCore_gv_cOMPUTER_Neutral)) {
        DialogControlSendAnimationEvent(libMMAP_gv_aVUI.lv_teamWinningIcon[lp_team], PlayerGroupAll(), "ShowEnlarge");
    }
    else {
        DialogControlSendAnimationEvent(libMMAP_gv_aVUI.lv_teamWinningIcon[libCore_gv_cOMPUTER_Neutral], PlayerGroupAll(), "Show");
    }
}

void libMMAP_gf_TeamDoesDoesNotCaptureFlag (int lp_team, int lp_enemyTeam, bool lp_isCapturing, bool lp_isContested) {
    // Variable Declarations
    playergroup lv_teamPlayerGroup;
    playergroup lv_enemyTeamPlayerGroup;
    string lv_isCapturing;
    string lv_isContested;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_teamPlayerGroup = libGame_gf_PlayersOnTeamHeroes(lp_team, false);
    lv_enemyTeamPlayerGroup = libGame_gf_PlayersOnTeamHeroes(lp_enemyTeam, false);
    lv_isCapturing = IntToString((lp_isCapturing));
    lv_isContested = IntToString((lp_isContested));

    // Implementation
    if ((lp_team == libGame_gv_teamOrderIndex_C)) {
        PlayerGroupAdd(lv_teamPlayerGroup, libCore_gv_cOMPUTER_Neutral);
    }
    else {
        PlayerGroupAdd(lv_enemyTeamPlayerGroup, libCore_gv_cOMPUTER_Neutral);
    }
    DialogControlSetAnimationState(libMMAP_gv_aVUI.lv_mMContainer, lv_teamPlayerGroup, "TopBarCaptured", (lv_isCapturing + lv_isContested));
    DialogControlSetAnimationState(libMMAP_gv_aVUI.lv_mMContainer, lv_enemyTeamPlayerGroup, "BottomBarCaptured", (lv_isCapturing + lv_isContested));
}

trigger auto_libMMAP_gf_ShowHideNotificationFrame_Trigger = null;
fixed auto_libMMAP_gf_ShowHideNotificationFrame_lp_duration;
int auto_libMMAP_gf_ShowHideNotificationFrame_lp_teamOfCaptor;
int auto_libMMAP_gf_ShowHideNotificationFrame_lp_teamOfCapturedFlag;

void libMMAP_gf_ShowHideNotificationFrame (fixed lp_duration, int lp_teamOfCaptor, int lp_teamOfCapturedFlag) {
    auto_libMMAP_gf_ShowHideNotificationFrame_lp_duration = lp_duration;
    auto_libMMAP_gf_ShowHideNotificationFrame_lp_teamOfCaptor = lp_teamOfCaptor;
    auto_libMMAP_gf_ShowHideNotificationFrame_lp_teamOfCapturedFlag = lp_teamOfCapturedFlag;

    if (auto_libMMAP_gf_ShowHideNotificationFrame_Trigger == null) {
        auto_libMMAP_gf_ShowHideNotificationFrame_Trigger = TriggerCreate("auto_libMMAP_gf_ShowHideNotificationFrame_TriggerFunc");
    }

    TriggerExecute(auto_libMMAP_gf_ShowHideNotificationFrame_Trigger, false, false);
}

bool auto_libMMAP_gf_ShowHideNotificationFrame_TriggerFunc (bool testConds, bool runActions) {
    fixed lp_duration = auto_libMMAP_gf_ShowHideNotificationFrame_lp_duration;
    int lp_teamOfCaptor = auto_libMMAP_gf_ShowHideNotificationFrame_lp_teamOfCaptor;
    int lp_teamOfCapturedFlag = auto_libMMAP_gf_ShowHideNotificationFrame_lp_teamOfCapturedFlag;

    // Variable Declarations
    int lv_notificationIndex;
    const fixed lv_hideAnimationDuration_c = 0.4375;
    playergroup lv_teamOfCaptorPlayerGroup;
    playergroup lv_enemyTeamOfCapturePlayerGroup;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_teamOfCaptorPlayerGroup = libGame_gf_PlayersOnTeamHeroes(lp_teamOfCaptor, false);
    lv_enemyTeamOfCapturePlayerGroup = libGame_gf_PlayersOnTeamHeroes(libGame_gf_EnemyTeam(lp_teamOfCaptor), false);

    // Implementation
    libMMAP_gv_aVUI.lv_notificationCount += 1;
    lv_notificationIndex = libMMAP_gv_aVUI.lv_notificationCount;
    if ((lp_teamOfCaptor == libGame_gv_teamOrderIndex_C)) {
        PlayerGroupAdd(lv_teamOfCaptorPlayerGroup, libCore_gv_cOMPUTER_Neutral);
    }
    else {
        PlayerGroupAdd(lv_enemyTeamOfCapturePlayerGroup, libCore_gv_cOMPUTER_Neutral);
    }
    if ((lp_teamOfCaptor != lp_teamOfCapturedFlag)) {
        libNtve_gf_SetDialogItemText(libMMAP_gv_aVUI.lv_notificationLabel[lv_notificationIndex], StringExternal("Param/Value/lib_MMAP_F2C25EDF"), lv_teamOfCaptorPlayerGroup);
        libNtve_gf_SetDialogItemText(libMMAP_gv_aVUI.lv_notificationLabel[lv_notificationIndex], StringExternal("Param/Value/lib_MMAP_9A842AA8"), lv_enemyTeamOfCapturePlayerGroup);
    }
    else {
        libNtve_gf_SetDialogItemText(libMMAP_gv_aVUI.lv_notificationLabel[lv_notificationIndex], StringExternal("Param/Value/lib_MMAP_517A2ABE"), lv_teamOfCaptorPlayerGroup);
        libNtve_gf_SetDialogItemText(libMMAP_gv_aVUI.lv_notificationLabel[lv_notificationIndex], StringExternal("Param/Value/lib_MMAP_40A4464B"), lv_enemyTeamOfCapturePlayerGroup);
    }
    DialogControlSetAnimationState(libMMAP_gv_aVUI.lv_notificationFrame[lv_notificationIndex], PlayerGroupAll(), "EventID", (IntToString(lp_teamOfCaptor) + IntToString(lp_teamOfCapturedFlag)));
    DialogControlSendAnimationEvent(libMMAP_gv_aVUI.lv_notificationFrame[lv_notificationIndex], PlayerGroupAll(), "Show");
    Wait((lp_duration - lv_hideAnimationDuration_c), c_timeGame);
    DialogControlSendAnimationEvent(libMMAP_gv_aVUI.lv_notificationFrame[lv_notificationIndex], PlayerGroupAll(), "Hide");
    Wait(lv_hideAnimationDuration_c, c_timeGame);
    libMMAP_gv_aVUI.lv_notificationCount -= 1;
    return true;
}

trigger auto_libMMAP_gf_UpdateNotificationCountdownLabel_Trigger = null;
text auto_libMMAP_gf_UpdateNotificationCountdownLabel_lp_alliedText;
text auto_libMMAP_gf_UpdateNotificationCountdownLabel_lp_enemyText;
int auto_libMMAP_gf_UpdateNotificationCountdownLabel_lp_alliedTeam;
timer auto_libMMAP_gf_UpdateNotificationCountdownLabel_lp_timer;

void libMMAP_gf_UpdateNotificationCountdownLabel (text lp_alliedText, text lp_enemyText, int lp_alliedTeam, timer lp_timer) {
    auto_libMMAP_gf_UpdateNotificationCountdownLabel_lp_alliedText = lp_alliedText;
    auto_libMMAP_gf_UpdateNotificationCountdownLabel_lp_enemyText = lp_enemyText;
    auto_libMMAP_gf_UpdateNotificationCountdownLabel_lp_alliedTeam = lp_alliedTeam;
    auto_libMMAP_gf_UpdateNotificationCountdownLabel_lp_timer = lp_timer;

    if (auto_libMMAP_gf_UpdateNotificationCountdownLabel_Trigger == null) {
        auto_libMMAP_gf_UpdateNotificationCountdownLabel_Trigger = TriggerCreate("auto_libMMAP_gf_UpdateNotificationCountdownLabel_TriggerFunc");
    }

    TriggerExecute(auto_libMMAP_gf_UpdateNotificationCountdownLabel_Trigger, false, false);
}

bool auto_libMMAP_gf_UpdateNotificationCountdownLabel_TriggerFunc (bool testConds, bool runActions) {
    text lp_alliedText = auto_libMMAP_gf_UpdateNotificationCountdownLabel_lp_alliedText;
    text lp_enemyText = auto_libMMAP_gf_UpdateNotificationCountdownLabel_lp_enemyText;
    int lp_alliedTeam = auto_libMMAP_gf_UpdateNotificationCountdownLabel_lp_alliedTeam;
    timer lp_timer = auto_libMMAP_gf_UpdateNotificationCountdownLabel_lp_timer;

    // Variable Declarations
    text lv_timerText;
    playergroup lv_alliedPlayerGroup;
    playergroup lv_enemyPlayerGroup;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_alliedPlayerGroup = libGame_gf_PlayersOnTeamHeroes(lp_alliedTeam, false);
    lv_enemyPlayerGroup = libGame_gf_PlayersOnTeamHeroes(libGame_gf_EnemyTeam(lp_alliedTeam), false);

    // Implementation
    if ((lp_alliedTeam == libGame_gv_teamOrderIndex_C)) {
        PlayerGroupAdd(lv_alliedPlayerGroup, libCore_gv_cOMPUTER_Neutral);
    }
    else {
        PlayerGroupAdd(lv_enemyPlayerGroup, libCore_gv_cOMPUTER_Neutral);
    }
    if ((lp_timer != null)) {
        while ((TimerGetRemaining(lp_timer) > 0)) {
            lv_timerText = TextTimeFormat(StringToText("<mintotal/>:<sec2/>"), FixedToInt(TimerGetRemaining(lp_timer)));
            TextExpressionSetToken("Param/Expression/lib_MMAP_6184A784", "A", lp_alliedText);
            TextExpressionSetToken("Param/Expression/lib_MMAP_6184A784", "B", lv_timerText);
            libNtve_gf_SetDialogItemText(libMMAP_gv_aVUI.lv_mechanicLabel, TextExpressionAssemble("Param/Expression/lib_MMAP_6184A784"), lv_alliedPlayerGroup);
            TextExpressionSetToken("Param/Expression/lib_MMAP_68F75484", "A", lp_enemyText);
            TextExpressionSetToken("Param/Expression/lib_MMAP_68F75484", "B", lv_timerText);
            libNtve_gf_SetDialogItemText(libMMAP_gv_aVUI.lv_mechanicLabel, TextExpressionAssemble("Param/Expression/lib_MMAP_68F75484"), lv_enemyPlayerGroup);
            Wait(1.0, c_timeGame);
        }
    }
    else {
        TextExpressionSetToken("Param/Expression/lib_MMAP_90CCDEED", "A", lp_alliedText);
        TextExpressionSetToken("Param/Expression/lib_MMAP_90CCDEED", "B", lv_timerText);
        libNtve_gf_SetDialogItemText(libMMAP_gv_aVUI.lv_mechanicLabel, TextExpressionAssemble("Param/Expression/lib_MMAP_90CCDEED"), lv_alliedPlayerGroup);
        TextExpressionSetToken("Param/Expression/lib_MMAP_52604118", "A", lp_enemyText);
        TextExpressionSetToken("Param/Expression/lib_MMAP_52604118", "B", lv_timerText);
        libNtve_gf_SetDialogItemText(libMMAP_gv_aVUI.lv_mechanicLabel, TextExpressionAssemble("Param/Expression/lib_MMAP_52604118"), lv_enemyPlayerGroup);
    }
    return true;
}

void libMMAP_gf_AttachHelpButtonToUnit (unit lp_attachedUnit, int lp_team, text lp_helpText, text lp_helpText2) {
    // Automatic Variable Declarations
    // Implementation
    libNtve_gf_SendActorMessageToUnit(lp_attachedUnit, "Signal CreateCaptureText");
}

trigger auto_libMMAP_gf_UpdateFlagUI_Trigger = null;
int auto_libMMAP_gf_UpdateFlagUI_lp_teamCapturingFlag;
int auto_libMMAP_gf_UpdateFlagUI_lp_teamOfCapturedFlag;

void libMMAP_gf_UpdateFlagUI (int lp_teamCapturingFlag, int lp_teamOfCapturedFlag) {
    auto_libMMAP_gf_UpdateFlagUI_lp_teamCapturingFlag = lp_teamCapturingFlag;
    auto_libMMAP_gf_UpdateFlagUI_lp_teamOfCapturedFlag = lp_teamOfCapturedFlag;

    if (auto_libMMAP_gf_UpdateFlagUI_Trigger == null) {
        auto_libMMAP_gf_UpdateFlagUI_Trigger = TriggerCreate("auto_libMMAP_gf_UpdateFlagUI_TriggerFunc");
    }

    TriggerExecute(auto_libMMAP_gf_UpdateFlagUI_Trigger, false, false);
}

bool auto_libMMAP_gf_UpdateFlagUI_TriggerFunc (bool testConds, bool runActions) {
    int lp_teamCapturingFlag = auto_libMMAP_gf_UpdateFlagUI_lp_teamCapturingFlag;
    int lp_teamOfCapturedFlag = auto_libMMAP_gf_UpdateFlagUI_lp_teamOfCapturedFlag;

    // Automatic Variable Declarations
    // Implementation
    while ((libMMAP_gv_aVMechanics[lp_teamOfCapturedFlag].lv_flagIsCaptured == true)) {
        if ((UnitGroupCount(libMMAP_gv_aVMechanics[lp_teamOfCapturedFlag].lv_flagEnemyHeroesCapturingUnitGroup, c_unitCountAlive) <= 0)) {
            TextExpressionSetToken("Param/Expression/lib_MMAP_BA578963", "A", StringExternal("Param/Value/lib_MMAP_685412A2"));
            TextExpressionSetToken("Param/Expression/lib_MMAP_BA578963", "B", StringExternal("Param/Value/lib_MMAP_FECF5B8B"));
            TextExpressionSetToken("Param/Expression/lib_MMAP_BA578963", "C", TextTimeFormat(StringToText("<mintotal/>:<sec2/>"), FixedToInt(libMMAP_gv_aVMechanics[lp_teamCapturingFlag].lv_victoryProgress)));
            TextTagSetText(libMMAP_gv_aVUI.lv_cageTextTag[lp_teamCapturingFlag][lp_teamCapturingFlag], TextExpressionAssemble("Param/Expression/lib_MMAP_BA578963"));
            TextExpressionSetToken("Param/Expression/lib_MMAP_62543C3F", "A", StringExternal("Param/Value/lib_MMAP_792FC7E7"));
            TextExpressionSetToken("Param/Expression/lib_MMAP_62543C3F", "B", StringExternal("Param/Value/lib_MMAP_EDABA208"));
            TextTagSetText(libMMAP_gv_aVUI.lv_cageTextTag[lp_teamCapturingFlag][lp_teamOfCapturedFlag], TextExpressionAssemble("Param/Expression/lib_MMAP_62543C3F"));
        }
        else {
            TextTagSetText(libMMAP_gv_aVUI.lv_cageTextTag[lp_teamCapturingFlag][lp_teamCapturingFlag], TextExpressionAssemble("Param/Expression/lib_MMAP_5680DAF8"));
            TextTagSetText(libMMAP_gv_aVUI.lv_cageTextTag[lp_teamCapturingFlag][lp_teamOfCapturedFlag], TextExpressionAssemble("Param/Expression/lib_MMAP_8AEAE885"));
        }
        Wait(0.0625, c_timeGame);
    }
    return true;
}

void libMMAP_gf_HookUpTeamSpecificSounds () {
    // Automatic Variable Declarations
    // Implementation
    libMMAP_gv_aVSounds.lv_aVTeamSpecificSounds[libGame_gv_teamOrderIndex_C].lv_cavalrySpawnWarning = SoundLink("UI_Game_AlteracPass_CavalryWarning_Alliance", -1);
    libMMAP_gv_aVSounds.lv_aVTeamSpecificSounds[libGame_gv_teamOrderIndex_C].lv_cavalrySpawn = SoundLink("UI_Game_AlteracPass_CavalrySpawn_Alliance", -1);
    libMMAP_gv_aVSounds.lv_aVTeamSpecificSounds[libGame_gv_teamOrderIndex_C].lv_coreGetHitLarge = SoundLink("VanndarA_VOX_GetHitLarge", -1);
    libMMAP_gv_aVSounds.lv_aVTeamSpecificSounds[libGame_gv_teamOrderIndex_C].lv_coreGetHitSmall = SoundLink("VanndarA_VOX_GetHitSmall", -1);
    libMMAP_gv_aVSounds.lv_aVTeamSpecificSounds[libGame_gv_teamChaosIndex_C].lv_cavalrySpawnWarning = SoundLink("UI_Game_AlteracPass_CavalryWarning_Horde", -1);
    libMMAP_gv_aVSounds.lv_aVTeamSpecificSounds[libGame_gv_teamChaosIndex_C].lv_cavalrySpawn = SoundLink("UI_Game_AlteracPass_CavalrySpawn_Horde", -1);
    libMMAP_gv_aVSounds.lv_aVTeamSpecificSounds[libGame_gv_teamChaosIndex_C].lv_coreGetHitLarge = SoundLink("DrekTharA_VOX_GetHitLarge", -1);
    libMMAP_gv_aVSounds.lv_aVTeamSpecificSounds[libGame_gv_teamChaosIndex_C].lv_coreGetHitSmall = SoundLink("DrekTharA_VOX_GetHitSmall", -1);
}

void libMMAP_gf_CoreTakesDamagePlayGetHitSound (int lp_team, fixed lp_damage) {
    // Automatic Variable Declarations
    // Implementation
    if (((lp_damage / (UnitGetPropertyFixed(libGame_gv_teams[lp_team].lv_core, c_unitPropLife, c_unitPropCurrent) + 1.0)) >= 0.05)) {
        SoundPlayOnUnitForPlayer(libMMAP_gv_aVSounds.lv_aVTeamSpecificSounds[lp_team].lv_coreGetHitLarge, c_maxPlayers, PlayerGroupAll(), libGame_gv_teams[lp_team].lv_core, 0.0, 100.0, 0.0);
    }
    else {
        SoundPlayOnUnitForPlayer(libMMAP_gv_aVSounds.lv_aVTeamSpecificSounds[lp_team].lv_coreGetHitSmall, c_maxPlayers, PlayerGroupAll(), libGame_gv_teams[lp_team].lv_core, 0.0, 100.0, 0.0);
    }
}

trigger auto_libMMAP_gf_CampSoon_Trigger = null;

void libMMAP_gf_CampSoon () {
    if (auto_libMMAP_gf_CampSoon_Trigger == null) {
        auto_libMMAP_gf_CampSoon_Trigger = TriggerCreate("auto_libMMAP_gf_CampSoon_TriggerFunc");
    }

    TriggerExecute(auto_libMMAP_gf_CampSoon_Trigger, false, false);
}

bool auto_libMMAP_gf_CampSoon_TriggerFunc (bool testConds, bool runActions) {
    // Variable Declarations
    playergroup lv_alliancePlayers;
    playergroup lv_hordePlayers;
    playergroup lv_observers;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_alliancePlayers = PlayerGroupEmpty();
    lv_hordePlayers = PlayerGroupEmpty();
    lv_observers = PlayerGroupEmpty();

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

    Wait(1.0, c_timeGame);
    TriggerQueueEnter();
    UserDataResetType("MapVOEvent");
    ConversationDataLineResetPlayers("AlteracValleyVO", ("Left"));
    ConversationDataLineResetPlayers("AlteracValleyVO", ("Right"));
    ConversationDataLineResetPlayers("AlteracValleyVO", ("Observer"));
    UserDataSetInt("MapVOEvent", "AP - CampSoon", "Value", 1, 1);
    if ((libMMAP_gv_firstEventHasHappened == false)) {
        UserDataSetInt("MapVOEvent", "AP - CampSoonFirst", "Value", 1, 1);
    }

    lv_alliancePlayers = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamOrderIndex_C, false);
    lv_hordePlayers = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamChaosIndex_C, false);
    lv_observers = libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer];
    ConversationDataLineSetPlayers("AlteracValleyVO", ("Left"), lv_alliancePlayers);
    ConversationDataLineSetPlayers("AlteracValleyVO", ("Right"), lv_hordePlayers);
    ConversationDataLineSetPlayers("AlteracValleyVO", ("Observer"), lv_observers);
    ConversationDataRun("AlteracValleyVO", PlayerGroupAll(), c_conversationSkipNone, false);
    libCore_gf_WaitForConversationToFinish();
    TriggerQueueExit();
    return true;
}

trigger auto_libMMAP_gf_CampActive_Trigger = null;

void libMMAP_gf_CampActive () {
    if (auto_libMMAP_gf_CampActive_Trigger == null) {
        auto_libMMAP_gf_CampActive_Trigger = TriggerCreate("auto_libMMAP_gf_CampActive_TriggerFunc");
    }

    TriggerExecute(auto_libMMAP_gf_CampActive_Trigger, false, false);
}

bool auto_libMMAP_gf_CampActive_TriggerFunc (bool testConds, bool runActions) {
    // Variable Declarations
    playergroup lv_alliancePlayers;
    playergroup lv_hordePlayers;
    playergroup lv_observers;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_alliancePlayers = PlayerGroupEmpty();
    lv_hordePlayers = PlayerGroupEmpty();
    lv_observers = PlayerGroupEmpty();

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

    TriggerQueueEnter();
    UserDataResetType("MapVOEvent");
    ConversationDataLineResetPlayers("AlteracValleyVO", ("Left"));
    ConversationDataLineResetPlayers("AlteracValleyVO", ("Right"));
    ConversationDataLineResetPlayers("AlteracValleyVO", ("Observer"));
    UserDataSetInt("MapVOEvent", "AP - CampActive", "Value", 1, 1);
    if ((libMMAP_gv_firstEventHasHappened == false)) {
        UserDataSetInt("MapVOEvent", "AP - CampActiveFirst", "Value", 1, 1);
    }

    lv_alliancePlayers = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamOrderIndex_C, false);
    lv_hordePlayers = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamChaosIndex_C, false);
    lv_observers = libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer];
    ConversationDataLineSetPlayers("AlteracValleyVO", ("Left"), lv_alliancePlayers);
    ConversationDataLineSetPlayers("AlteracValleyVO", ("Right"), lv_hordePlayers);
    ConversationDataLineSetPlayers("AlteracValleyVO", ("Observer"), lv_observers);
    ConversationDataRun("AlteracValleyVO", PlayerGroupAll(), c_conversationSkipNone, false);
    libCore_gf_WaitForConversationToFinish();
    TriggerQueueExit();
    return true;
}

trigger auto_libMMAP_gf_AllianceCapturesHordeCamp_Trigger = null;

void libMMAP_gf_AllianceCapturesHordeCamp () {
    if (auto_libMMAP_gf_AllianceCapturesHordeCamp_Trigger == null) {
        auto_libMMAP_gf_AllianceCapturesHordeCamp_Trigger = TriggerCreate("auto_libMMAP_gf_AllianceCapturesHordeCamp_TriggerFunc");
    }

    TriggerExecute(auto_libMMAP_gf_AllianceCapturesHordeCamp_Trigger, false, false);
}

bool auto_libMMAP_gf_AllianceCapturesHordeCamp_TriggerFunc (bool testConds, bool runActions) {
    // Variable Declarations
    playergroup lv_alliancePlayers;
    playergroup lv_hordePlayers;
    playergroup lv_observers;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_alliancePlayers = PlayerGroupEmpty();
    lv_hordePlayers = PlayerGroupEmpty();
    lv_observers = PlayerGroupEmpty();

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

    libMMAP_gv_aVTransmissions.lv_hasPlayedCampCapturedVO[libGame_gv_teamOrderIndex_C] = true;
    TimerStart(libMMAP_gv_aVTransmissions.lv_campTransmissionCDTimer, libMMAP_gv_transmissionCDTimerDuration_C, false, c_timeGame);
    TriggerQueueEnter();
    UserDataResetType("MapVOEvent");
    ConversationDataLineResetPlayers("AlteracValleyVO", ("Left"));
    ConversationDataLineResetPlayers("AlteracValleyVO", ("Right"));
    ConversationDataLineResetPlayers("AlteracValleyVO", ("Observer"));
    UserDataSetInt("MapVOEvent", "AP - CampCapturedLeft", "Value", 1, 1);
    lv_alliancePlayers = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamOrderIndex_C, false);
    lv_hordePlayers = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamChaosIndex_C, false);
    lv_observers = libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer];
    ConversationDataLineSetPlayers("AlteracValleyVO", ("Left"), lv_alliancePlayers);
    ConversationDataLineSetPlayers("AlteracValleyVO", ("Right"), lv_hordePlayers);
    ConversationDataLineSetPlayers("AlteracValleyVO", ("Observer"), lv_observers);
    ConversationDataRun("AlteracValleyVO", PlayerGroupAll(), c_conversationSkipNone, false);
    libCore_gf_WaitForConversationToFinish();
    TriggerQueueExit();
    return true;
}

trigger auto_libMMAP_gf_HordeCapturesAllianceCamp_Trigger = null;

void libMMAP_gf_HordeCapturesAllianceCamp () {
    if (auto_libMMAP_gf_HordeCapturesAllianceCamp_Trigger == null) {
        auto_libMMAP_gf_HordeCapturesAllianceCamp_Trigger = TriggerCreate("auto_libMMAP_gf_HordeCapturesAllianceCamp_TriggerFunc");
    }

    TriggerExecute(auto_libMMAP_gf_HordeCapturesAllianceCamp_Trigger, false, false);
}

bool auto_libMMAP_gf_HordeCapturesAllianceCamp_TriggerFunc (bool testConds, bool runActions) {
    // Variable Declarations
    playergroup lv_alliancePlayers;
    playergroup lv_hordePlayers;
    playergroup lv_observers;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_alliancePlayers = PlayerGroupEmpty();
    lv_hordePlayers = PlayerGroupEmpty();
    lv_observers = PlayerGroupEmpty();

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

    TimerStart(libMMAP_gv_aVTransmissions.lv_campTransmissionCDTimer, libMMAP_gv_transmissionCDTimerDuration_C, false, c_timeGame);
    libMMAP_gv_aVTransmissions.lv_hasPlayedCampCapturedVO[libGame_gv_teamChaosIndex_C] = true;
    TriggerQueueEnter();
    UserDataResetType("MapVOEvent");
    ConversationDataLineResetPlayers("AlteracValleyVO", ("Left"));
    ConversationDataLineResetPlayers("AlteracValleyVO", ("Right"));
    ConversationDataLineResetPlayers("AlteracValleyVO", ("Observer"));
    UserDataSetInt("MapVOEvent", "AP - CampCapturedRight", "Value", 1, 1);
    lv_alliancePlayers = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamOrderIndex_C, false);
    lv_hordePlayers = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamChaosIndex_C, false);
    lv_observers = libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer];
    ConversationDataLineSetPlayers("AlteracValleyVO", ("Left"), lv_alliancePlayers);
    ConversationDataLineSetPlayers("AlteracValleyVO", ("Right"), lv_hordePlayers);
    ConversationDataLineSetPlayers("AlteracValleyVO", ("Observer"), lv_observers);
    ConversationDataRun("AlteracValleyVO", PlayerGroupAll(), c_conversationSkipNone, false);
    libCore_gf_WaitForConversationToFinish();
    TriggerQueueExit();
    return true;
}

trigger auto_libMMAP_gf_AllianceRetakesAllianceCamp_Trigger = null;

void libMMAP_gf_AllianceRetakesAllianceCamp () {
    if (auto_libMMAP_gf_AllianceRetakesAllianceCamp_Trigger == null) {
        auto_libMMAP_gf_AllianceRetakesAllianceCamp_Trigger = TriggerCreate("auto_libMMAP_gf_AllianceRetakesAllianceCamp_TriggerFunc");
    }

    TriggerExecute(auto_libMMAP_gf_AllianceRetakesAllianceCamp_Trigger, false, false);
}

bool auto_libMMAP_gf_AllianceRetakesAllianceCamp_TriggerFunc (bool testConds, bool runActions) {
    // Variable Declarations
    playergroup lv_alliancePlayers;
    playergroup lv_hordePlayers;
    playergroup lv_observers;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_alliancePlayers = PlayerGroupEmpty();
    lv_hordePlayers = PlayerGroupEmpty();
    lv_observers = PlayerGroupEmpty();

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

    TimerStart(libMMAP_gv_aVTransmissions.lv_campTransmissionCDTimer, libMMAP_gv_transmissionCDTimerDuration_C, false, c_timeGame);
    libMMAP_gv_aVTransmissions.lv_hasPlayedCampRetakenVO[libGame_gv_teamOrderIndex_C] = true;
    TriggerQueueEnter();
    UserDataResetType("MapVOEvent");
    ConversationDataLineResetPlayers("AlteracValleyVO", ("Left"));
    ConversationDataLineResetPlayers("AlteracValleyVO", ("Right"));
    ConversationDataLineResetPlayers("AlteracValleyVO", ("Observer"));
    UserDataSetInt("MapVOEvent", "AP - CampRetakenLeft", "Value", 1, 1);
    lv_alliancePlayers = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamOrderIndex_C, false);
    lv_hordePlayers = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamChaosIndex_C, false);
    lv_observers = libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer];
    ConversationDataLineSetPlayers("AlteracValleyVO", ("Left"), lv_alliancePlayers);
    ConversationDataLineSetPlayers("AlteracValleyVO", ("Right"), lv_hordePlayers);
    ConversationDataLineSetPlayers("AlteracValleyVO", ("Observer"), lv_observers);
    ConversationDataRun("AlteracValleyVO", PlayerGroupAll(), c_conversationSkipNone, false);
    libCore_gf_WaitForConversationToFinish();
    TriggerQueueExit();
    return true;
}

trigger auto_libMMAP_gf_HordeRetakesHordeCamp_Trigger = null;

void libMMAP_gf_HordeRetakesHordeCamp () {
    if (auto_libMMAP_gf_HordeRetakesHordeCamp_Trigger == null) {
        auto_libMMAP_gf_HordeRetakesHordeCamp_Trigger = TriggerCreate("auto_libMMAP_gf_HordeRetakesHordeCamp_TriggerFunc");
    }

    TriggerExecute(auto_libMMAP_gf_HordeRetakesHordeCamp_Trigger, false, false);
}

bool auto_libMMAP_gf_HordeRetakesHordeCamp_TriggerFunc (bool testConds, bool runActions) {
    // Variable Declarations
    playergroup lv_alliancePlayers;
    playergroup lv_hordePlayers;
    playergroup lv_observers;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_alliancePlayers = PlayerGroupEmpty();
    lv_hordePlayers = PlayerGroupEmpty();
    lv_observers = PlayerGroupEmpty();

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

    TimerStart(libMMAP_gv_aVTransmissions.lv_campTransmissionCDTimer, libMMAP_gv_transmissionCDTimerDuration_C, false, c_timeGame);
    libMMAP_gv_aVTransmissions.lv_hasPlayedCampRetakenVO[libGame_gv_teamChaosIndex_C] = true;
    TriggerQueueEnter();
    UserDataResetType("MapVOEvent");
    ConversationDataLineResetPlayers("AlteracValleyVO", ("Left"));
    ConversationDataLineResetPlayers("AlteracValleyVO", ("Right"));
    ConversationDataLineResetPlayers("AlteracValleyVO", ("Observer"));
    UserDataSetInt("MapVOEvent", "AP - CampRetakenRight", "Value", 1, 1);
    lv_alliancePlayers = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamOrderIndex_C, false);
    lv_hordePlayers = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamChaosIndex_C, false);
    lv_observers = libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer];
    ConversationDataLineSetPlayers("AlteracValleyVO", ("Left"), lv_alliancePlayers);
    ConversationDataLineSetPlayers("AlteracValleyVO", ("Right"), lv_hordePlayers);
    ConversationDataLineSetPlayers("AlteracValleyVO", ("Observer"), lv_observers);
    ConversationDataRun("AlteracValleyVO", PlayerGroupAll(), c_conversationSkipNone, false);
    libCore_gf_WaitForConversationToFinish();
    TriggerQueueExit();
    return true;
}

trigger auto_libMMAP_gf_AllianceWinsObjective_Trigger = null;

void libMMAP_gf_AllianceWinsObjective () {
    if (auto_libMMAP_gf_AllianceWinsObjective_Trigger == null) {
        auto_libMMAP_gf_AllianceWinsObjective_Trigger = TriggerCreate("auto_libMMAP_gf_AllianceWinsObjective_TriggerFunc");
    }

    TriggerExecute(auto_libMMAP_gf_AllianceWinsObjective_Trigger, false, false);
}

bool auto_libMMAP_gf_AllianceWinsObjective_TriggerFunc (bool testConds, bool runActions) {
    // Variable Declarations
    playergroup lv_alliancePlayers;
    playergroup lv_hordePlayers;
    playergroup lv_observers;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_alliancePlayers = PlayerGroupEmpty();
    lv_hordePlayers = PlayerGroupEmpty();
    lv_observers = PlayerGroupEmpty();

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

    TriggerQueueEnter();
    UserDataResetType("MapVOEvent");
    ConversationDataLineResetPlayers("AlteracValleyVO", ("Left"));
    ConversationDataLineResetPlayers("AlteracValleyVO", ("Right"));
    ConversationDataLineResetPlayers("AlteracValleyVO", ("Observer"));
    UserDataSetInt("MapVOEvent", "AP - CampVictoryLeft", "Value", 1, 1);
    if ((libMMAP_gv_aVMechanics[libGame_gv_teamOrderIndex_C].lv_eventsWon == 0)) {
        UserDataSetInt("MapVOEvent", "AP - CampVictoryFirstLeft", "Value", 1, 1);
    }

    lv_alliancePlayers = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamOrderIndex_C, false);
    lv_hordePlayers = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamChaosIndex_C, false);
    lv_observers = libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer];
    ConversationDataLineSetPlayers("AlteracValleyVO", ("Left"), lv_alliancePlayers);
    ConversationDataLineSetPlayers("AlteracValleyVO", ("Right"), lv_hordePlayers);
    ConversationDataLineSetPlayers("AlteracValleyVO", ("Observer"), lv_observers);
    ConversationDataRun("AlteracValleyVO", PlayerGroupAll(), c_conversationSkipNone, false);
    libCore_gf_WaitForConversationToFinish();
    TriggerQueueExit();
    return true;
}

trigger auto_libMMAP_gf_HordeWinsObjective_Trigger = null;

void libMMAP_gf_HordeWinsObjective () {
    if (auto_libMMAP_gf_HordeWinsObjective_Trigger == null) {
        auto_libMMAP_gf_HordeWinsObjective_Trigger = TriggerCreate("auto_libMMAP_gf_HordeWinsObjective_TriggerFunc");
    }

    TriggerExecute(auto_libMMAP_gf_HordeWinsObjective_Trigger, false, false);
}

bool auto_libMMAP_gf_HordeWinsObjective_TriggerFunc (bool testConds, bool runActions) {
    // Variable Declarations
    playergroup lv_alliancePlayers;
    playergroup lv_hordePlayers;
    playergroup lv_observers;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_alliancePlayers = PlayerGroupEmpty();
    lv_hordePlayers = PlayerGroupEmpty();
    lv_observers = PlayerGroupEmpty();

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

    TriggerQueueEnter();
    UserDataResetType("MapVOEvent");
    ConversationDataLineResetPlayers("AlteracValleyVO", ("Left"));
    ConversationDataLineResetPlayers("AlteracValleyVO", ("Right"));
    ConversationDataLineResetPlayers("AlteracValleyVO", ("Observer"));
    UserDataSetInt("MapVOEvent", "AP - CampVictoryRight", "Value", 1, 1);
    if ((libMMAP_gv_aVMechanics[libGame_gv_teamChaosIndex_C].lv_eventsWon == 0)) {
        UserDataSetInt("MapVOEvent", "AP - CampVictoryFirstRight", "Value", 1, 1);
    }

    lv_alliancePlayers = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamOrderIndex_C, false);
    lv_hordePlayers = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamChaosIndex_C, false);
    lv_observers = libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer];
    ConversationDataLineSetPlayers("AlteracValleyVO", ("Left"), lv_alliancePlayers);
    ConversationDataLineSetPlayers("AlteracValleyVO", ("Right"), lv_hordePlayers);
    ConversationDataLineSetPlayers("AlteracValleyVO", ("Observer"), lv_observers);
    ConversationDataRun("AlteracValleyVO", PlayerGroupAll(), c_conversationSkipNone, false);
    libCore_gf_WaitForConversationToFinish();
    TriggerQueueExit();
    return true;
}

trigger auto_libMMAP_gf_AllianceCavalryCharges_Trigger = null;

void libMMAP_gf_AllianceCavalryCharges () {
    if (auto_libMMAP_gf_AllianceCavalryCharges_Trigger == null) {
        auto_libMMAP_gf_AllianceCavalryCharges_Trigger = TriggerCreate("auto_libMMAP_gf_AllianceCavalryCharges_TriggerFunc");
    }

    TriggerExecute(auto_libMMAP_gf_AllianceCavalryCharges_Trigger, false, false);
}

bool auto_libMMAP_gf_AllianceCavalryCharges_TriggerFunc (bool testConds, bool runActions) {
    // Variable Declarations
    playergroup lv_alliancePlayers;
    playergroup lv_hordePlayers;
    playergroup lv_observers;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_alliancePlayers = PlayerGroupEmpty();
    lv_hordePlayers = PlayerGroupEmpty();
    lv_observers = PlayerGroupEmpty();

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

    TriggerQueueEnter();
    UserDataResetType("MapVOEvent");
    ConversationDataLineResetPlayers("AlteracValleyVO", ("Left"));
    ConversationDataLineResetPlayers("AlteracValleyVO", ("Right"));
    ConversationDataLineResetPlayers("AlteracValleyVO", ("Observer"));
    UserDataSetInt("MapVOEvent", "AP - CavalrySpawnsLeft", "Value", 1, 1);
    lv_alliancePlayers = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamOrderIndex_C, false);
    lv_hordePlayers = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamChaosIndex_C, false);
    lv_observers = libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer];
    ConversationDataLineSetPlayers("AlteracValleyVO", ("Left"), lv_alliancePlayers);
    ConversationDataLineSetPlayers("AlteracValleyVO", ("Right"), lv_hordePlayers);
    ConversationDataLineSetPlayers("AlteracValleyVO", ("Observer"), lv_observers);
    ConversationDataRun("AlteracValleyVO", PlayerGroupAll(), c_conversationSkipNone, false);
    libCore_gf_WaitForConversationToFinish();
    TriggerQueueExit();
    return true;
}

trigger auto_libMMAP_gf_HordeCavalryCharges_Trigger = null;

void libMMAP_gf_HordeCavalryCharges () {
    if (auto_libMMAP_gf_HordeCavalryCharges_Trigger == null) {
        auto_libMMAP_gf_HordeCavalryCharges_Trigger = TriggerCreate("auto_libMMAP_gf_HordeCavalryCharges_TriggerFunc");
    }

    TriggerExecute(auto_libMMAP_gf_HordeCavalryCharges_Trigger, false, false);
}

bool auto_libMMAP_gf_HordeCavalryCharges_TriggerFunc (bool testConds, bool runActions) {
    // Variable Declarations
    playergroup lv_alliancePlayers;
    playergroup lv_hordePlayers;
    playergroup lv_observers;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_alliancePlayers = PlayerGroupEmpty();
    lv_hordePlayers = PlayerGroupEmpty();
    lv_observers = PlayerGroupEmpty();

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

    TriggerQueueEnter();
    UserDataResetType("MapVOEvent");
    ConversationDataLineResetPlayers("AlteracValleyVO", ("Left"));
    ConversationDataLineResetPlayers("AlteracValleyVO", ("Right"));
    ConversationDataLineResetPlayers("AlteracValleyVO", ("Observer"));
    UserDataSetInt("MapVOEvent", "AP - CavalrySpawnsRight", "Value", 1, 1);
    lv_alliancePlayers = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamOrderIndex_C, false);
    lv_hordePlayers = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamChaosIndex_C, false);
    lv_observers = libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer];
    ConversationDataLineSetPlayers("AlteracValleyVO", ("Left"), lv_alliancePlayers);
    ConversationDataLineSetPlayers("AlteracValleyVO", ("Right"), lv_hordePlayers);
    ConversationDataLineSetPlayers("AlteracValleyVO", ("Observer"), lv_observers);
    ConversationDataRun("AlteracValleyVO", PlayerGroupAll(), c_conversationSkipNone, false);
    libCore_gf_WaitForConversationToFinish();
    TriggerQueueExit();
    return true;
}

trigger auto_libMMAP_gf_AllianceCavalrySlain_Trigger = null;

void libMMAP_gf_AllianceCavalrySlain () {
    if (auto_libMMAP_gf_AllianceCavalrySlain_Trigger == null) {
        auto_libMMAP_gf_AllianceCavalrySlain_Trigger = TriggerCreate("auto_libMMAP_gf_AllianceCavalrySlain_TriggerFunc");
    }

    TriggerExecute(auto_libMMAP_gf_AllianceCavalrySlain_Trigger, false, false);
}

bool auto_libMMAP_gf_AllianceCavalrySlain_TriggerFunc (bool testConds, bool runActions) {
    // Variable Declarations
    playergroup lv_alliancePlayers;
    playergroup lv_hordePlayers;
    playergroup lv_observers;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_alliancePlayers = PlayerGroupEmpty();
    lv_hordePlayers = PlayerGroupEmpty();
    lv_observers = PlayerGroupEmpty();

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

    TriggerQueueEnter();
    UserDataResetType("MapVOEvent");
    ConversationDataLineResetPlayers("AlteracValleyVO", ("Left"));
    ConversationDataLineResetPlayers("AlteracValleyVO", ("Right"));
    ConversationDataLineResetPlayers("AlteracValleyVO", ("Observer"));
    UserDataSetInt("MapVOEvent", "AP - CavalryDeadLeft", "Value", 1, 1);
    lv_alliancePlayers = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamOrderIndex_C, false);
    lv_hordePlayers = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamChaosIndex_C, false);
    lv_observers = libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer];
    ConversationDataLineSetPlayers("AlteracValleyVO", ("Left"), lv_alliancePlayers);
    ConversationDataLineSetPlayers("AlteracValleyVO", ("Right"), lv_hordePlayers);
    ConversationDataLineSetPlayers("AlteracValleyVO", ("Observer"), lv_observers);
    ConversationDataRun("AlteracValleyVO", PlayerGroupAll(), c_conversationSkipNone, false);
    libCore_gf_WaitForConversationToFinish();
    TriggerQueueExit();
    return true;
}

trigger auto_libMMAP_gf_HordeCavalrySlain_Trigger = null;

void libMMAP_gf_HordeCavalrySlain () {
    if (auto_libMMAP_gf_HordeCavalrySlain_Trigger == null) {
        auto_libMMAP_gf_HordeCavalrySlain_Trigger = TriggerCreate("auto_libMMAP_gf_HordeCavalrySlain_TriggerFunc");
    }

    TriggerExecute(auto_libMMAP_gf_HordeCavalrySlain_Trigger, false, false);
}

bool auto_libMMAP_gf_HordeCavalrySlain_TriggerFunc (bool testConds, bool runActions) {
    // Variable Declarations
    playergroup lv_alliancePlayers;
    playergroup lv_hordePlayers;
    playergroup lv_observers;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_alliancePlayers = PlayerGroupEmpty();
    lv_hordePlayers = PlayerGroupEmpty();
    lv_observers = PlayerGroupEmpty();

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

    TriggerQueueEnter();
    UserDataResetType("MapVOEvent");
    ConversationDataLineResetPlayers("AlteracValleyVO", ("Left"));
    ConversationDataLineResetPlayers("AlteracValleyVO", ("Right"));
    ConversationDataLineResetPlayers("AlteracValleyVO", ("Observer"));
    UserDataSetInt("MapVOEvent", "AP - CavalryDeadRight", "Value", 1, 1);
    lv_alliancePlayers = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamOrderIndex_C, false);
    lv_hordePlayers = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamChaosIndex_C, false);
    lv_observers = libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer];
    ConversationDataLineSetPlayers("AlteracValleyVO", ("Left"), lv_alliancePlayers);
    ConversationDataLineSetPlayers("AlteracValleyVO", ("Right"), lv_hordePlayers);
    ConversationDataLineSetPlayers("AlteracValleyVO", ("Observer"), lv_observers);
    ConversationDataRun("AlteracValleyVO", PlayerGroupAll(), c_conversationSkipNone, false);
    libCore_gf_WaitForConversationToFinish();
    TriggerQueueExit();
    return true;
}

// Triggers
//--------------------------------------------------------------------------------------------------
// Trigger: Include Mod Init
//--------------------------------------------------------------------------------------------------
bool libMMAP_gt_IncludeModInit_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_i;
    fixed lv_captureMacguffinPeriodCount;

    // Automatic Variable Declarations
    const int auto919E8947_ae = libCore_gv_bALMaxPlayers;
    const int auto919E8947_ai = 1;
    const int auto86981657_ae = libCore_gv_cOMPUTER_TeamChaos;
    const int auto86981657_ai = 1;

    // Variable Initialization
    lv_captureMacguffinPeriodCount = CatalogFieldValueGetAsFixed(c_gameCatalogEffect, "CaptureMacGuffin", "PeriodicPeriodArray[" + IntToString(0) + "]", c_playerAny);

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

    TriggerEnable(libMMAP_gt_GameOpenTimerStarted, true);
    TriggerEnable(libMMAP_gt_OpenTheGatesTimerExpires, true);
    TriggerEnable(libMMAP_gt_GameOver, true);
    lib7EB401DE_gf_WarcraftSetPlayerFaction(libCore_gv_cOMPUTER_TeamOrder, lib7EB401DE_ge_WarcraftFaction_Alliance);
    lib7EB401DE_gf_WarcraftSetPlayerFaction(libCore_gv_cOMPUTER_TeamChaos, lib7EB401DE_ge_WarcraftFaction_Horde);
    lib7EB401DE_gf_WarcraftSetPlayerFaction(libCore_gv_cOMPUTER_NoVision_TeamOrder, lib7EB401DE_ge_WarcraftFaction_Alliance);
    lib7EB401DE_gf_WarcraftSetPlayerFaction(libCore_gv_cOMPUTER_NoVision_TeamChaos, lib7EB401DE_ge_WarcraftFaction_Horde);
    libMMAP_gf_InitializeMapMVPAnnouncerSounds();
    if ((libCore_gv_dEBUGDebuggingEnabled == true)) {
        TriggerEnable(libMMAP_gt_DEBUG_Help, true);
        TriggerEnable(libMMAP_gt_DEBUG_SendEnemyMapMechanicReward, true);
        TriggerEnable(libMMAP_gt_DEBUG_EventStart, true);
        TriggerEnable(libMMAP_gt_DEBUG_EventStartFast, true);
        TriggerEnable(libMMAP_gt_DEBUG_MakeAlliedFlagsTargetable, true);
        TriggerEnable(libMMAP_gt_DEBUG_ToggleDefenders, true);
    }

    libMMAP_gv_aVMechanics[libGame_gv_teamOrderIndex_C].lv_cavalrySpawnTrigger = libMMAP_gt_OrderCavalrySpawnTimerExpires;
    libMMAP_gv_aVMechanics[libGame_gv_teamChaosIndex_C].lv_cavalrySpawnTrigger = libMMAP_gt_ChaosCavalrySpawnTimerExpires;
    libMMAP_gv_aVMechanics[libGame_gv_teamOrderIndex_C].lv_cavalryDeathTracker = libMMAP_gt_OrderRewardDeathTracker;
    libMMAP_gv_aVMechanics[libGame_gv_teamChaosIndex_C].lv_cavalryDeathTracker = libMMAP_gt_ChaosRewardDeathTracker;
    libMMAP_gv_aVMechanics[libGame_gv_teamOrderIndex_C].lv_defenderDeathTracker = libMMAP_gt_OrderDefenderDies;
    libMMAP_gv_aVMechanics[libGame_gv_teamChaosIndex_C].lv_defenderDeathTracker = libMMAP_gt_ChaosDefenderDies;
    libMMAP_gv_aVMechanics[libGame_gv_teamOrderIndex_C].lv_defenderSpawnTracker = libMMAP_gt_OrderDefenderSpawnTimerExpires;
    libMMAP_gv_aVMechanics[libGame_gv_teamChaosIndex_C].lv_defenderSpawnTracker = libMMAP_gt_ChaosDefenderSpawnTimerExpires;
    libMMAP_gv_aVMechanics[libGame_gv_teamOrderIndex_C].lv_cavalryUnitType = libMMAP_gv_allianceCavalryUnitType_C;
    libMMAP_gv_aVMechanics[libGame_gv_teamChaosIndex_C].lv_cavalryUnitType = libMMAP_gv_hordeCavalryUnitType_C;
    libMMAP_gv_aVMechanics[libGame_gv_teamOrderIndex_C].lv_flagBirthActorType = libMMAP_gv_capturedAllianceSoldierBirthActorType_C;
    libMMAP_gv_aVMechanics[libGame_gv_teamChaosIndex_C].lv_flagBirthActorType = libMMAP_gv_capturedHordeSoldierBirthActorType_C;
    libMMAP_gv_aVMechanics[libGame_gv_teamOrderIndex_C].lv_cavalryBirthActorType = libMMAP_gv_allianceCavalryBirthActor_C;
    libMMAP_gv_aVMechanics[libGame_gv_teamChaosIndex_C].lv_cavalryBirthActorType = libMMAP_gv_hordeCavalryBirthActor_C;
    libMMAP_gf_OverrideMinionWaveComposition();
    lv_i = 1;
    for ( ; ( (auto919E8947_ai >= 0 && lv_i <= auto919E8947_ae) || (auto919E8947_ai < 0 && lv_i >= auto919E8947_ae) ) ; lv_i += auto919E8947_ai ) {
        CatalogFieldValueSet(c_gameCatalogEffect, "CaptureMacGuffin", "PeriodCount", lv_i, FixedToString((libMMAP_gv_heroTimeToCap_C / lv_captureMacguffinPeriodCount), c_fixedPrecisionAny));
    }
    lv_i = libCore_gv_cOMPUTER_TeamOrder;
    for ( ; ( (auto86981657_ai >= 0 && lv_i <= auto86981657_ae) || (auto86981657_ai < 0 && lv_i >= auto86981657_ae) ) ; lv_i += auto86981657_ai ) {
        CatalogFieldValueSet(c_gameCatalogEffect, "CaptureMacGuffin", "PeriodCount", lv_i, FixedToString((libMMAP_gv_minionTimeToCap_C / lv_captureMacguffinPeriodCount), c_fixedPrecisionAny));
    }
    libMMAP_gf_HookUpUI();
    libGame_gf_SendMapSpecificAwardInitializeEventwithUserData(null, "Generic Instance");
    libMMAP_gf_HookUpTeamSpecificSounds();
    libUIUI_gf_PingCreateNewPingTarget("AVCapturePointDefender", false, StringExternal("Param/Value/lib_MMAP_5C623B18"), StringExternal("Param/Value/lib_MMAP_59CD13AA"), StringExternal("Param/Value/lib_MMAP_7FC233D0"), SoundLink("UI_Game_Ping_Defend", -1), SoundLink("UI_Game_Ping_Attack", -1));
    libUIUI_gf_PingCreateNewPingTarget("CapturedSoldier", false, StringExternal("Param/Value/lib_MMAP_9B9D6F6C"), StringExternal("Param/Value/lib_MMAP_2546397C"), StringExternal("Param/Value/lib_MMAP_7783E20B"), SoundLink("UI_Game_Ping_Defend", -1), SoundLink("UI_Game_Ping_Defend", -1));
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMMAP_gt_IncludeModInit_Init () {
    libMMAP_gt_IncludeModInit = TriggerCreate("libMMAP_gt_IncludeModInit_Func");
    libCore_gf_IncludeModInitialization(libMMAP_gt_IncludeModInit);
}

//--------------------------------------------------------------------------------------------------
// Trigger: DEBUG_Help
//--------------------------------------------------------------------------------------------------
bool libMMAP_gt_DEBUG_Help_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {
            return false;
        }
    }

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

    TriggerDebugOutput(1, StringExternal("Param/Value/lib_MMAP_8BF6B30B"), true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMMAP_gt_DEBUG_Help_Init () {
    libMMAP_gt_DEBUG_Help = TriggerCreate("libMMAP_gt_DEBUG_Help_Func");
    TriggerEnable(libMMAP_gt_DEBUG_Help, false);
    libGame_gf_GameOpenTimerStarted(libMMAP_gt_DEBUG_Help);
    TriggerAddEventChatMessage(libMMAP_gt_DEBUG_Help, c_playerAny, "!help", true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: DEBUG_Send Enemy Map Mechanic Reward
//--------------------------------------------------------------------------------------------------
bool libMMAP_gt_DEBUG_SendEnemyMapMechanicReward_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {
            return false;
        }
    }

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

    if ((EventChatMessage(false) == "sendwaveleft")) {
        libMMAP_gf_SpawnCavalryForTeam(libGame_gv_teamOrderIndex_C);
    }
    else {
        libMMAP_gf_SpawnCavalryForTeam(libGame_gv_teamChaosIndex_C);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMMAP_gt_DEBUG_SendEnemyMapMechanicReward_Init () {
    libMMAP_gt_DEBUG_SendEnemyMapMechanicReward = TriggerCreate("libMMAP_gt_DEBUG_SendEnemyMapMechanicReward_Func");
    TriggerEnable(libMMAP_gt_DEBUG_SendEnemyMapMechanicReward, false);
    TriggerAddEventChatMessage(libMMAP_gt_DEBUG_SendEnemyMapMechanicReward, c_playerAny, "sendwaveleft", true);
    TriggerAddEventChatMessage(libMMAP_gt_DEBUG_SendEnemyMapMechanicReward, c_playerAny, "sendwaveright", true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: DEBUG_Toggle Defenders
//--------------------------------------------------------------------------------------------------
bool libMMAP_gt_DEBUG_ToggleDefenders_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_i;
    int lv_u;

    // Automatic Variable Declarations
    const int auto28AF6F37_ae = libGame_gv_teamChaosIndex_C;
    const int auto28AF6F37_ai = 1;
    const int auto7D873DD1_ae = libGame_gv_teamChaosIndex_C;
    const int auto7D873DD1_ai = 1;
    int autoAEC23BF0_ae;
    const int autoAEC23BF0_ai = 1;

    // Variable Initialization

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

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

    libMMAP_gv_dEBUG_CampDefendersOn = !(libMMAP_gv_dEBUG_CampDefendersOn);
    if ((libMMAP_gv_dEBUG_CampDefendersOn == false)) {
        lv_i = libGame_gv_teamOrderIndex_C;
        for ( ; ( (auto7D873DD1_ai >= 0 && lv_i <= auto7D873DD1_ae) || (auto7D873DD1_ai < 0 && lv_i >= auto7D873DD1_ae) ) ; lv_i += auto7D873DD1_ai ) {
            autoAEC23BF0_ae = libMMAP_gv_defenderCount;
            lv_u = 1;
            for ( ; ( (autoAEC23BF0_ai >= 0 && lv_u <= autoAEC23BF0_ae) || (autoAEC23BF0_ai < 0 && lv_u >= autoAEC23BF0_ae) ) ; lv_u += autoAEC23BF0_ai ) {
                UnitRemove(libMMAP_gv_aVMechanics[lv_i].lv_defenderUnit[lv_u]);
            }
        }
    }
    else {
        if ((TimerGetRemaining(libMMAP_gv_eventTimer) <= 0.0)) {
            lv_i = libGame_gv_teamOrderIndex_C;
            for ( ; ( (auto28AF6F37_ai >= 0 && lv_i <= auto28AF6F37_ae) || (auto28AF6F37_ai < 0 && lv_i >= auto28AF6F37_ae) ) ; lv_i += auto28AF6F37_ai ) {
                libMMAP_gf_SpawnAllDefendersImmediately(lv_i);
            }
        }

    }
    TextExpressionSetToken("Param/Expression/lib_MMAP_E4E00F33", "A", libNtve_gf_ConvertBooleanToText(libMMAP_gv_dEBUG_CampDefendersOn));
    TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_MMAP_E4E00F33"), true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMMAP_gt_DEBUG_ToggleDefenders_Init () {
    libMMAP_gt_DEBUG_ToggleDefenders = TriggerCreate("libMMAP_gt_DEBUG_ToggleDefenders_Func");
    TriggerEnable(libMMAP_gt_DEBUG_ToggleDefenders, false);
    TriggerAddEventChatMessage(libMMAP_gt_DEBUG_ToggleDefenders, c_playerAny, "togcampdefenders", true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: DEBUG_Event Start
//--------------------------------------------------------------------------------------------------
bool libMMAP_gt_DEBUG_EventStart_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {
            return false;
        }
    }

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

    TriggerExecute(libMMAP_gt_DEBUG_MakeAlliedFlagsTargetable, true, false);
    TimerStart(libGame_gv_openTheGatesTimer, 0.0, false, c_timeGame);
    Wait(0.0625, c_timeGame);
    TimerStart(libMMAP_gv_eventObjectivePreviewTimer, 0.0, false, c_timeGame);
    Wait(0.0625, c_timeGame);
    TimerStart(libMMAP_gv_eventWarningTimer, 0.0, false, c_timeGame);
    Wait(0.0625, c_timeGame);
    TimerStart(libMMAP_gv_eventTimer, libMMAP_gv_eventTimerWarningDuration_C, false, c_timeGame);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMMAP_gt_DEBUG_EventStart_Init () {
    libMMAP_gt_DEBUG_EventStart = TriggerCreate("libMMAP_gt_DEBUG_EventStart_Func");
    TriggerEnable(libMMAP_gt_DEBUG_EventStart, false);
    TriggerAddEventChatMessage(libMMAP_gt_DEBUG_EventStart, c_playerAny, "eventstart", true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: DEBUG_Event Start Fast
//--------------------------------------------------------------------------------------------------
bool libMMAP_gt_DEBUG_EventStartFast_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {
            return false;
        }
    }

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

    TriggerExecute(libMMAP_gt_DEBUG_EventStart, true, true);
    TimerStart(libMMAP_gv_eventTimer, 0.0625, false, c_timeGame);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMMAP_gt_DEBUG_EventStartFast_Init () {
    libMMAP_gt_DEBUG_EventStartFast = TriggerCreate("libMMAP_gt_DEBUG_EventStartFast_Func");
    TriggerEnable(libMMAP_gt_DEBUG_EventStartFast, false);
    TriggerAddEventChatMessage(libMMAP_gt_DEBUG_EventStartFast, c_playerAny, "eventstartfast", true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: DEBUG_Make Allied Flags Targetable
//--------------------------------------------------------------------------------------------------
bool libMMAP_gt_DEBUG_MakeAlliedFlagsTargetable_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((libCore_gv_dEBUGDebuggingEnabled == true))) {
            return false;
        }
    }

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

    libMMAP_gv_dEBUG_AlliedFlagTargetable = !(libMMAP_gv_dEBUG_AlliedFlagTargetable);
    TextExpressionSetToken("Param/Expression/lib_MMAP_6B811A80", "A", libNtve_gf_ConvertBooleanToText(libMMAP_gv_dEBUG_AlliedFlagTargetable));
    TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_MMAP_6B811A80"), true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMMAP_gt_DEBUG_MakeAlliedFlagsTargetable_Init () {
    libMMAP_gt_DEBUG_MakeAlliedFlagsTargetable = TriggerCreate("libMMAP_gt_DEBUG_MakeAlliedFlagsTargetable_Func");
    TriggerEnable(libMMAP_gt_DEBUG_MakeAlliedFlagsTargetable, false);
    TriggerAddEventChatMessage(libMMAP_gt_DEBUG_MakeAlliedFlagsTargetable, c_playerAny, "targetable", true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Game Open Timer Started
//--------------------------------------------------------------------------------------------------
bool libMMAP_gt_GameOpenTimerStarted_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_lane;
    int lv_team;

    // Automatic Variable Declarations
    const int autoAD8CCD5F_ae = libGame_gv_teamChaosIndex_C;
    const int autoAD8CCD5F_ai = 1;
    const int auto369C63C4_ae = libMMAP_gv_aVLaneCount_C;
    const int auto369C63C4_ai = 1;

    // Variable Initialization

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

    lv_team = libGame_gv_teamOrderIndex_C;
    for ( ; ( (autoAD8CCD5F_ai >= 0 && lv_team <= autoAD8CCD5F_ae) || (autoAD8CCD5F_ai < 0 && lv_team >= autoAD8CCD5F_ae) ) ; lv_team += autoAD8CCD5F_ai ) {
        libNtve_gf_SendActorMessageToUnit(libGame_gv_teams[lv_team].lv_core, "Signal GameStartBirth");
        lv_lane = 1;
        for ( ; ( (auto369C63C4_ai >= 0 && lv_lane <= auto369C63C4_ae) || (auto369C63C4_ai < 0 && lv_lane >= auto369C63C4_ae) ) ; lv_lane += auto369C63C4_ai ) {
            UnitBehaviorAdd(libGame_gv_teams[lv_team].lv_core, "WarchiefAlive", libMMAP_gv_aVMechanics[lv_team].lv_keep[lv_lane], 1);
        }
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMMAP_gt_GameOpenTimerStarted_Init () {
    libMMAP_gt_GameOpenTimerStarted = TriggerCreate("libMMAP_gt_GameOpenTimerStarted_Func");
    TriggerEnable(libMMAP_gt_GameOpenTimerStarted, false);
    libGame_gf_GameOpenTimerStarted(libMMAP_gt_GameOpenTimerStarted);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Open The Gates Timer Expires
//--------------------------------------------------------------------------------------------------
bool libMMAP_gt_OpenTheGatesTimerExpires_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_team;

    // Automatic Variable Declarations
    const int auto14719782_ae = libGame_gv_teamChaosIndex_C;
    const int auto14719782_ai = 1;

    // Variable Initialization

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

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerEnable(libMMAP_gt_EventObjectivePreviewTimerExpires, true);
    TriggerEnable(libMMAP_gt_EventWarningTimerExpires, true);
    TriggerEnable(libMMAP_gt_EventTimerExpires, true);
    TriggerEnable(libMMAP_gt_TownStructureDiesRemoveBossArmor, true);
    TimerStart(libMMAP_gv_eventObjectivePreviewTimer, libMMAP_gv_eventObectivePreviewDuration_C, false, c_timeGame);
    TimerStart(libMMAP_gv_eventTimer, libMMAP_gv_eventTimerDurationStartDuration_C, false, c_timeGame);
    TimerStart(libMMAP_gv_eventWarningTimer, (libMMAP_gv_eventTimerDurationStartDuration_C - libMMAP_gv_eventTimerWarningDuration_C), false, c_timeGame);
    lv_team = libGame_gv_teamOrderIndex_C;
    for ( ; ( (auto14719782_ai >= 0 && lv_team <= auto14719782_ae) || (auto14719782_ai < 0 && lv_team >= auto14719782_ae) ) ; lv_team += auto14719782_ai ) {
        libAIAI_gf_StartDefenderAI(true, libNtve_gf_ConvertUnitToUnitGroup(libGame_gv_teams[lv_team].lv_core), libMMAP_gv_aVMechanics[lv_team].lv_bossLeashRegion, libMMAP_gv_aVMechanics[lv_team].lv_bossAggroRegion, false);
        libAIAI_gf_SetDefendersShowLeashedText(libAIAI_gf_LastCreatedDefenderAI(), true);
        libAIAI_gf_SetDefendersAggroOnComputerPlayers(libAIAI_gf_LastCreatedDefenderAI(), true);
    }
    Wait(1.5, c_timeGame);
    libSond_gf_SoundtrackApplyNewDefaultSoundtrackForPlayerGroup("MX_AlteracPass_GameStart", PlayerGroupAll());
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMMAP_gt_OpenTheGatesTimerExpires_Init () {
    libMMAP_gt_OpenTheGatesTimerExpires = TriggerCreate("libMMAP_gt_OpenTheGatesTimerExpires_Func");
    TriggerEnable(libMMAP_gt_OpenTheGatesTimerExpires, false);
    TriggerAddEventTimer(libMMAP_gt_OpenTheGatesTimerExpires, libGame_gv_openTheGatesTimer);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Event Objective Preview Timer Expires
//--------------------------------------------------------------------------------------------------
bool libMMAP_gt_EventObjectivePreviewTimerExpires_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_team;

    // Automatic Variable Declarations
    // Variable Initialization

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

    TriggerEnable(TriggerGetCurrent(), false);
    lv_team = libGame_gv_teamOrderIndex_C;
    ActorSend(libMMAP_gv_aVMechanics[lv_team].lv_flagCaptureDoodadActor[libMMAP_gv_currentCPIndex], "Signal PrepareOn");
    libNtve_gf_CreateUnitsWithDefaultFacing(1, "AVCaptureFlagPreviewDummyAlliance", c_unitCreateIgnorePlacement, libMMAP_gf_NoVisionComputerPlayerInTeam(lv_team), libMMAP_gv_aVMechanics[lv_team].lv_flagSpawnPoint[libMMAP_gv_currentCPIndex], null);
    libMMAP_gv_aVMechanics[lv_team].lv_flagWarningUnit = UnitLastCreated();
    lv_team = libGame_gv_teamChaosIndex_C;
    ActorSend(libMMAP_gv_aVMechanics[lv_team].lv_flagCaptureDoodadActor[libMMAP_gv_currentCPIndex], "Signal PrepareOn");
    libNtve_gf_CreateUnitsWithDefaultFacing(1, "AVCaptureFlagPreviewDummyHorde", c_unitCreateIgnorePlacement, libMMAP_gf_NoVisionComputerPlayerInTeam(lv_team), libMMAP_gv_aVMechanics[lv_team].lv_flagSpawnPoint[libMMAP_gv_currentCPIndex], null);
    libMMAP_gv_aVMechanics[lv_team].lv_flagWarningUnit = UnitLastCreated();
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMMAP_gt_EventObjectivePreviewTimerExpires_Init () {
    libMMAP_gt_EventObjectivePreviewTimerExpires = TriggerCreate("libMMAP_gt_EventObjectivePreviewTimerExpires_Func");
    TriggerEnable(libMMAP_gt_EventObjectivePreviewTimerExpires, false);
    TriggerAddEventTimer(libMMAP_gt_EventObjectivePreviewTimerExpires, libMMAP_gv_eventObjectivePreviewTimer);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Event Warning Timer Expires
//--------------------------------------------------------------------------------------------------
bool libMMAP_gt_EventWarningTimerExpires_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_team;
    int lv_i;

    // Automatic Variable Declarations
    const int autoCBDB1CB5_ae = libGame_gv_teamChaosIndex_C;
    const int autoCBDB1CB5_ai = 1;
    int auto1CF02ECF_ae;
    const int auto1CF02ECF_ai = 1;

    // Variable Initialization

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

    TriggerEnable(TriggerGetCurrent(), false);
    SoundPlayForPlayer(SoundLink("UI_Game_AlteracPass_EventWarning", -1), c_maxPlayers, PlayerGroupAll(), 100.0, 0.0);
    libSond_gf_SoundtrackApplyNewDefaultSoundtrackForPlayerGroup("MX_AlteracPass_EventWarning", PlayerGroupAll());
    libMMAP_gf_CampSoon();
    PingCreateFromDataWithPlayerId(PlayerGroupSingle(libCore_gv_oBSERVER_ObserverUIPlayer), "Defend", libMMAP_gv_aVMechanics[libGame_gv_teamOrderIndex_C].lv_flagSpawnPoint[libMMAP_gv_currentCPIndex], libGame_gf_ComputerPlayerInTeam(libGame_gv_teamOrderIndex_C));
    PingSetDuration(PingLastCreated(), libMMAP_gv_eventTimerWarningDuration_C);
    PingCreateFromDataWithPlayerId(PlayerGroupSingle(libCore_gv_oBSERVER_ObserverUIPlayer), "Attack", libMMAP_gv_aVMechanics[libGame_gv_teamChaosIndex_C].lv_flagSpawnPoint[libMMAP_gv_currentCPIndex], libGame_gf_ComputerPlayerInTeam(libGame_gv_teamChaosIndex_C));
    PingSetDuration(PingLastCreated(), libMMAP_gv_eventTimerWarningDuration_C);
    lv_team = libGame_gv_teamOrderIndex_C;
    for ( ; ( (autoCBDB1CB5_ai >= 0 && lv_team <= autoCBDB1CB5_ae) || (autoCBDB1CB5_ai < 0 && lv_team >= autoCBDB1CB5_ae) ) ; lv_team += autoCBDB1CB5_ai ) {
        UnitRemove(libMMAP_gv_aVMechanics[lv_team].lv_flagWarningUnit);
        libNtve_gf_CreateActorWithPointFacing(libMMAP_gv_aVMechanics[lv_team].lv_flagBirthActorType, libMMAP_gv_aVMechanics[libGame_gf_EnemyTeam(lv_team)].lv_flagSpawnPoint[libMMAP_gv_currentCPIndex]);
        libMMAP_gv_aVMechanics[lv_team].lv_flagBirthActor = libNtve_gf_ActorLastCreated();
        ActorSend(libMMAP_gv_aVMechanics[lv_team].lv_flagBirthActor, "TimerSet "+(IntToString(libMMAP_gv_eventTimerWarningDuration_C - 2))+" DestroyTimer");
        PingCreateFromDataWithPlayerId(libGame_gf_PlayersOnTeamHeroes(lv_team, false), "Defend", libMMAP_gv_aVMechanics[lv_team].lv_flagSpawnPoint[libMMAP_gv_currentCPIndex], libGame_gf_ComputerPlayerInTeam(lv_team));
        PingSetDuration(PingLastCreated(), libMMAP_gv_eventTimerWarningDuration_C);
        PingCreateFromDataWithPlayerId(libGame_gf_PlayersOnTeamHeroes(lv_team, false), "Attack", libMMAP_gv_aVMechanics[libGame_gf_EnemyTeam(lv_team)].lv_flagSpawnPoint[libMMAP_gv_currentCPIndex], libGame_gf_ComputerPlayerInTeam(libGame_gf_EnemyTeam(lv_team)));
        PingSetDuration(PingLastCreated(), libMMAP_gv_eventTimerWarningDuration_C);
        libMMAP_gf_UpdateNotificationCountdownLabel(StringExternal("Param/Value/lib_MMAP_022215B2"), StringExternal("Param/Value/lib_MMAP_B563C334"), 1, libMMAP_gv_eventTimer);
        auto1CF02ECF_ae = libMMAP_gv_defenderCount;
        lv_i = 1;
        for ( ; ( (auto1CF02ECF_ai >= 0 && lv_i <= auto1CF02ECF_ae) || (auto1CF02ECF_ai < 0 && lv_i >= auto1CF02ECF_ae) ) ; lv_i += auto1CF02ECF_ai ) {
            libMMAP_gv_aVMechanics[lv_team].lv_defenderNextSpawnPointIndex[lv_i] = libMMAP_gf_GetDefenderSpawnPointIndex(lv_team);
            ActorSend(libMMAP_gv_aVMechanics[lv_team].lv_defenderSpawnDoodadActor[libMMAP_gv_currentCPIndex][libMMAP_gv_aVMechanics[lv_team].lv_defenderNextSpawnPointIndex[lv_i]], "Signal Work");
        }
    }
    DialogControlSendAnimationEvent(libMMAP_gv_aVUI.lv_mMContainer, PlayerGroupAll(), "Show");
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMMAP_gt_EventWarningTimerExpires_Init () {
    libMMAP_gt_EventWarningTimerExpires = TriggerCreate("libMMAP_gt_EventWarningTimerExpires_Func");
    TriggerEnable(libMMAP_gt_EventWarningTimerExpires, false);
    TriggerAddEventTimer(libMMAP_gt_EventWarningTimerExpires, libMMAP_gv_eventWarningTimer);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Event Timer Expires
//--------------------------------------------------------------------------------------------------
bool libMMAP_gt_EventTimerExpires_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_team;

    // Automatic Variable Declarations
    const int autoA661B987_ae = libGame_gv_teamChaosIndex_C;
    const int autoA661B987_ai = 1;

    // Variable Initialization

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

    TriggerEnable(TriggerGetCurrent(), false);
    SoundPlayForPlayer(SoundLink("UI_Game_AlteracPass_EventStart", -1), c_maxPlayers, PlayerGroupAll(), 100.0, 0.0);
    libMMAP_gf_CampActive();
    libSond_gf_SoundtrackApplyNewDefaultSoundtrackForPlayerGroup("MX_AlteracPass_Event", PlayerGroupAll());
    libMMAP_gf_UpdateVictoriousTeamIcon(libCore_gv_cOMPUTER_Neutral);
    libMMAP_gf_UpdateTeamIconForTeamCurrentlyWinning(libCore_gv_cOMPUTER_Neutral);
    DialogControlSendAnimationEvent(libMMAP_gv_aVUI.lv_mMContainer, PlayerGroupAll(), "MapMechanicActive");
    TriggerEnable(libMMAP_gt_PlayerCompletesChannelMacguffin, true);
    TriggerEnable(libMMAP_gt_PlayerStartsChannelMacguffin, true);
    TriggerEnable(libMMAP_gt_PlayerInterruptsChannelMacguffin, true);
    lv_team = libGame_gv_teamOrderIndex_C;
    for ( ; ( (autoA661B987_ai >= 0 && lv_team <= autoA661B987_ae) || (autoA661B987_ai < 0 && lv_team >= autoA661B987_ae) ) ; lv_team += autoA661B987_ai ) {
        libMMAP_gf_EnableDisableCaptureFlag(lv_team, true);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMMAP_gt_EventTimerExpires_Init () {
    libMMAP_gt_EventTimerExpires = TriggerCreate("libMMAP_gt_EventTimerExpires_Func");
    TriggerEnable(libMMAP_gt_EventTimerExpires, false);
    TriggerAddEventTimer(libMMAP_gt_EventTimerExpires, libMMAP_gv_eventTimer);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Game Over
//--------------------------------------------------------------------------------------------------
bool libMMAP_gt_GameOver_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_playerIterator;

    // Automatic Variable Declarations
    int auto9F33E234_ae;

    // Variable Initialization

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

    auto9F33E234_ae = libCore_gv_bALMaxPlayers;
    lv_playerIterator = 1;
    for ( ; lv_playerIterator <= auto9F33E234_ae ; lv_playerIterator += 1 ) {
        libGame_gf_ScoreValuesReportIntegerValueAndLog(lv_playerIterator, "CageUnlocksInterrupted", libMMAP_gv_cageUnlockInterrupts[lv_playerIterator]);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMMAP_gt_GameOver_Init () {
    libMMAP_gt_GameOver = TriggerCreate("libMMAP_gt_GameOver_Func");
    TriggerEnable(libMMAP_gt_GameOver, false);
    libGame_gf_GameOverEvent(libMMAP_gt_GameOver);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Town Structure Dies - Remove Boss Armor
//--------------------------------------------------------------------------------------------------
bool libMMAP_gt_TownStructureDiesRemoveBossArmor_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_dyingStructureUnit;
    int lv_victimTeam;
    int lv_townIndex;
    int lv_structureType;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_dyingStructureUnit = EventUnit();
    lv_structureType = libGame_ge_TownStructureTypes_None;

    // Conditions
    if (testConds) {
        if (!((UnitTypeTestAttribute(UnitGetType(lv_dyingStructureUnit), c_unitAttributeStructure) == true))) {
            return false;
        }

        if (!((UnitTypeTestAttribute(UnitGetType(lv_dyingStructureUnit), c_unitAttributeSummoned) == false))) {
            return false;
        }

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

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

    lv_townIndex = libGame_gf_TownGetTownForUnit(lv_dyingStructureUnit);
    lv_structureType = libGame_gf_TownGetTownStructurePresetFromUnit(lv_dyingStructureUnit);
    lv_victimTeam = libGame_gf_TeamNumberOfPlayer(UnitGetOwner(lv_dyingStructureUnit));
    if ((lv_structureType == libGame_ge_TownStructureTypes_TownHall) && (libGame_gf_TownAliveinLane(lv_victimTeam, libGame_gv_townTownData[lv_townIndex].lv_lane) == false)) {
        UnitBehaviorRemove(libGame_gv_teams[lv_victimTeam].lv_core, "WarchiefAlive", 1);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libMMAP_gt_TownStructureDiesRemoveBossArmor_Init () {
    libMMAP_gt_TownStructureDiesRemoveBossArmor = TriggerCreate("libMMAP_gt_TownStructureDiesRemoveBossArmor_Func");
    TriggerEnable(libMMAP_gt_TownStructureDiesRemoveBossArmor, false);
    TriggerAddEventUnitDied(libMMAP_gt_TownStructureDiesRemoveBossArmor, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Order Defender Spawn Timer Expires
//--------------------------------------------------------------------------------------------------
bool libMMAP_gt_OrderDefenderSpawnTimerExpires_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((libMMAP_gv_aVMechanics[libGame_gv_teamOrderIndex_C].lv_respawnDefenders == true))) {
            return false;
        }
    }

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

    libMMAP_gf_DefenderSpawnTimerExpires(libGame_gv_teamOrderIndex_C, EventTimer());
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMMAP_gt_OrderDefenderSpawnTimerExpires_Init () {
    libMMAP_gt_OrderDefenderSpawnTimerExpires = TriggerCreate("libMMAP_gt_OrderDefenderSpawnTimerExpires_Func");
    TriggerEnable(libMMAP_gt_OrderDefenderSpawnTimerExpires, false);
    TriggerAddEventTimer(libMMAP_gt_OrderDefenderSpawnTimerExpires, libMMAP_gv_aVMechanics[libGame_gv_teamOrderIndex_C].lv_defenderSpawnTimer[1]);
    TriggerAddEventTimer(libMMAP_gt_OrderDefenderSpawnTimerExpires, libMMAP_gv_aVMechanics[libGame_gv_teamOrderIndex_C].lv_defenderSpawnTimer[2]);
    TriggerAddEventTimer(libMMAP_gt_OrderDefenderSpawnTimerExpires, libMMAP_gv_aVMechanics[libGame_gv_teamOrderIndex_C].lv_defenderSpawnTimer[3]);
    TriggerAddEventTimer(libMMAP_gt_OrderDefenderSpawnTimerExpires, libMMAP_gv_aVMechanics[libGame_gv_teamOrderIndex_C].lv_defenderSpawnTimer[4]);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Chaos Defender Spawn Timer Expires
//--------------------------------------------------------------------------------------------------
bool libMMAP_gt_ChaosDefenderSpawnTimerExpires_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((libMMAP_gv_aVMechanics[libGame_gv_teamChaosIndex_C].lv_respawnDefenders == true))) {
            return false;
        }
    }

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

    libMMAP_gf_DefenderSpawnTimerExpires(libGame_gv_teamChaosIndex_C, EventTimer());
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMMAP_gt_ChaosDefenderSpawnTimerExpires_Init () {
    libMMAP_gt_ChaosDefenderSpawnTimerExpires = TriggerCreate("libMMAP_gt_ChaosDefenderSpawnTimerExpires_Func");
    TriggerEnable(libMMAP_gt_ChaosDefenderSpawnTimerExpires, false);
    TriggerAddEventTimer(libMMAP_gt_ChaosDefenderSpawnTimerExpires, libMMAP_gv_aVMechanics[libGame_gv_teamChaosIndex_C].lv_defenderSpawnTimer[1]);
    TriggerAddEventTimer(libMMAP_gt_ChaosDefenderSpawnTimerExpires, libMMAP_gv_aVMechanics[libGame_gv_teamChaosIndex_C].lv_defenderSpawnTimer[2]);
    TriggerAddEventTimer(libMMAP_gt_ChaosDefenderSpawnTimerExpires, libMMAP_gv_aVMechanics[libGame_gv_teamChaosIndex_C].lv_defenderSpawnTimer[3]);
    TriggerAddEventTimer(libMMAP_gt_ChaosDefenderSpawnTimerExpires, libMMAP_gv_aVMechanics[libGame_gv_teamChaosIndex_C].lv_defenderSpawnTimer[4]);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Order Defender Dies
//--------------------------------------------------------------------------------------------------
bool libMMAP_gt_OrderDefenderDies_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((libMMAP_gv_aVMechanics[libGame_gv_teamOrderIndex_C].lv_respawnDefenders == true))) {
            return false;
        }
    }

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

    libMMAP_gf_FlagDefenderDies(EventUnit(), libGame_gv_teamOrderIndex_C);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMMAP_gt_OrderDefenderDies_Init () {
    libMMAP_gt_OrderDefenderDies = TriggerCreate("libMMAP_gt_OrderDefenderDies_Func");
    TriggerEnable(libMMAP_gt_OrderDefenderDies, false);
    TriggerAddEventUnitDied(libMMAP_gt_OrderDefenderDies, UnitRefFromVariable("libMMAP_gv_aVMechanics[libGame_gv_teamOrderIndex_C].lv_defenderUnit[1]"));
    TriggerAddEventUnitDied(libMMAP_gt_OrderDefenderDies, UnitRefFromVariable("libMMAP_gv_aVMechanics[libGame_gv_teamOrderIndex_C].lv_defenderUnit[2]"));
    TriggerAddEventUnitDied(libMMAP_gt_OrderDefenderDies, UnitRefFromVariable("libMMAP_gv_aVMechanics[libGame_gv_teamOrderIndex_C].lv_defenderUnit[3]"));
    TriggerAddEventUnitDied(libMMAP_gt_OrderDefenderDies, UnitRefFromVariable("libMMAP_gv_aVMechanics[libGame_gv_teamOrderIndex_C].lv_defenderUnit[4]"));
}

//--------------------------------------------------------------------------------------------------
// Trigger: Chaos Defender Dies
//--------------------------------------------------------------------------------------------------
bool libMMAP_gt_ChaosDefenderDies_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((libMMAP_gv_aVMechanics[libGame_gv_teamChaosIndex_C].lv_respawnDefenders == true))) {
            return false;
        }
    }

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

    libMMAP_gf_FlagDefenderDies(EventUnit(), libGame_gv_teamChaosIndex_C);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMMAP_gt_ChaosDefenderDies_Init () {
    libMMAP_gt_ChaosDefenderDies = TriggerCreate("libMMAP_gt_ChaosDefenderDies_Func");
    TriggerEnable(libMMAP_gt_ChaosDefenderDies, false);
    TriggerAddEventUnitDied(libMMAP_gt_ChaosDefenderDies, UnitRefFromVariable("libMMAP_gv_aVMechanics[libGame_gv_teamChaosIndex_C].lv_defenderUnit[1]"));
    TriggerAddEventUnitDied(libMMAP_gt_ChaosDefenderDies, UnitRefFromVariable("libMMAP_gv_aVMechanics[libGame_gv_teamChaosIndex_C].lv_defenderUnit[2]"));
    TriggerAddEventUnitDied(libMMAP_gt_ChaosDefenderDies, UnitRefFromVariable("libMMAP_gv_aVMechanics[libGame_gv_teamChaosIndex_C].lv_defenderUnit[3]"));
    TriggerAddEventUnitDied(libMMAP_gt_ChaosDefenderDies, UnitRefFromVariable("libMMAP_gv_aVMechanics[libGame_gv_teamChaosIndex_C].lv_defenderUnit[4]"));
}

//--------------------------------------------------------------------------------------------------
// Trigger: DEBUG_WatchDefenderAi
//--------------------------------------------------------------------------------------------------
bool libMMAP_gt_DEBUG_WatchDefenderAi_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_defenderUnit;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_defenderUnit = UnitGroupClosestToPoint(UnitGroup("AVCapturePointDefender", c_playerAny, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0), CameraGetTarget(EventPlayer()));

    // Conditions
    if (testConds) {
        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {
            return false;
        }

        if (!((UnitIsValid(lv_defenderUnit) == true))) {
            return false;
        }
    }

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

    if ((libMMAP_gv_dEBUG_WatchedDefender != null)) {
        UnitBehaviorRemove(libMMAP_gv_dEBUG_WatchedDefender, "DebugWatchedFlagDefender", 1);
    }

    libMMAP_gv_dEBUG_WatchedDefender = lv_defenderUnit;
    UnitBehaviorAdd(lv_defenderUnit, "DebugWatchedFlagDefender", lv_defenderUnit, 1);
    TextExpressionSetToken("Param/Expression/lib_MMAP_46214EA8", "A", UnitGetName(lv_defenderUnit));
    TextExpressionSetToken("Param/Expression/lib_MMAP_46214EA8", "B", IntToText(UnitGetTag(lv_defenderUnit)));
    TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_MMAP_46214EA8"), true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMMAP_gt_DEBUG_WatchDefenderAi_Init () {
    libMMAP_gt_DEBUG_WatchDefenderAi = TriggerCreate("libMMAP_gt_DEBUG_WatchDefenderAi_Func");
    TriggerAddEventChatMessage(libMMAP_gt_DEBUG_WatchDefenderAi, c_playerAny, "watchdefender", true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Player Starts Channel Macguffin
//--------------------------------------------------------------------------------------------------
bool libMMAP_gt_PlayerStartsChannelMacguffin_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_teamOfEventPlayer_c;
    int lv_enemyTeamOfEventPlayer_c;
    unit lv_eventEffectTarget_c;
    unit lv_eventEffectCaster_c;
    bool lv_pausingCaptureProgress;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_teamOfEventPlayer_c = libGame_gf_TeamNumberOfPlayer(EventPlayerEffectUsedUnitOwner(c_effectPlayerCaster));
    lv_enemyTeamOfEventPlayer_c = libGame_gf_EnemyTeam(lv_teamOfEventPlayer_c);
    lv_eventEffectTarget_c = EventPlayerEffectUsedUnit(c_effectUnitTarget);
    lv_eventEffectCaster_c = EventPlayerEffectUsedUnit(c_effectUnitCaster);

    // Conditions
    if (testConds) {
        if (!(((lv_eventEffectTarget_c == libMMAP_gv_aVMechanics[libGame_gv_teamOrderIndex_C].lv_flag) || (lv_eventEffectTarget_c == libMMAP_gv_aVMechanics[libGame_gv_teamChaosIndex_C].lv_flag)))) {
            return false;
        }
    }

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

    if ((lv_eventEffectTarget_c != libMMAP_gv_aVMechanics[lv_enemyTeamOfEventPlayer_c].lv_flag) && (libMMAP_gv_aVMechanics[lv_teamOfEventPlayer_c].lv_flagIsCaptured == true)) {
        if ((libGame_gf_UnitIsHero(lv_eventEffectCaster_c) == true)) {
            UnitGroupAdd(libMMAP_gv_aVMechanics[lv_teamOfEventPlayer_c].lv_flagEnemyHeroesCapturingUnitGroup, lv_eventEffectCaster_c);
            lv_pausingCaptureProgress = true;
            libMMAP_gf_TeamDoesDoesNotCaptureFlag(lv_enemyTeamOfEventPlayer_c, lv_teamOfEventPlayer_c, true, true);
            ActorSend(libMMAP_gv_aVMechanics[lv_teamOfEventPlayer_c].lv_flagCaptureDoodadActor[libMMAP_gv_currentCPIndex], "SetPlayerId");
            UnitSetOwner(libMMAP_gv_aVMechanics[lv_teamOfEventPlayer_c].lv_cageUnit[libMMAP_gv_currentCPIndex], libCore_gv_cOMPUTER_Neutral, true);
            UnitIssueOrder(lv_eventEffectTarget_c, Order(AbilityCommand("stop", 0)), c_orderQueueReplace);
        }

        UnitGroupAdd(libMMAP_gv_aVMechanics[lv_teamOfEventPlayer_c].lv_flagEnemiesCapturingUnitGroup, lv_eventEffectCaster_c);
    }

    if ((UnitIsValid(libMMAP_gv_aVMechanics[lv_teamOfEventPlayer_c].lv_flagBeingCapturedUnit) == false)) {
        libNtve_gf_CreateUnitsWithDefaultFacing(1, "AVCapturePointBeingCappedDummy", c_unitCreateIgnorePlacement, libMMAP_gf_NoVisionComputerPlayerInTeam(lv_teamOfEventPlayer_c), UnitGetPosition(lv_eventEffectTarget_c), null);
        libMMAP_gv_aVMechanics[lv_teamOfEventPlayer_c].lv_flagBeingCapturedUnit = UnitLastCreated();
    }

    while ((OrderGetAbilityCommand(UnitOrder(lv_eventEffectCaster_c, 0)) == AbilityCommand("CaptureMacGuffin", 0))) {
        Wait(0.0625, c_timeGame);
    }
    UnitGroupRemove(libMMAP_gv_aVMechanics[lv_teamOfEventPlayer_c].lv_flagEnemiesCapturingUnitGroup, lv_eventEffectCaster_c);
    if ((lv_pausingCaptureProgress == true)) {
        UnitGroupRemove(libMMAP_gv_aVMechanics[lv_teamOfEventPlayer_c].lv_flagEnemyHeroesCapturingUnitGroup, lv_eventEffectCaster_c);
        if ((UnitGroupCount(libMMAP_gv_aVMechanics[lv_teamOfEventPlayer_c].lv_flagEnemyHeroesCapturingUnitGroup, c_unitCountAlive) <= 0) && (libMMAP_gv_aVMechanics[lv_teamOfEventPlayer_c].lv_flagIsCaptured == true)) {
            libMMAP_gf_TeamDoesDoesNotCaptureFlag(lv_enemyTeamOfEventPlayer_c, lv_teamOfEventPlayer_c, true, false);
            ActorSend(libMMAP_gv_aVMechanics[lv_teamOfEventPlayer_c].lv_flagCaptureDoodadActor[libMMAP_gv_currentCPIndex], "SetPlayerId "+IntToString((libGame_gf_ComputerPlayerInTeam(lv_enemyTeamOfEventPlayer_c))));
            UnitSetOwner(libMMAP_gv_aVMechanics[lv_teamOfEventPlayer_c].lv_cageUnit[libMMAP_gv_currentCPIndex], libMMAP_gf_NoVisionComputerPlayerInTeam(lv_enemyTeamOfEventPlayer_c), true);
            UnitIssueOrder(lv_eventEffectTarget_c, OrderTargetingUnit(AbilityCommand("CapturedSoldierDummyAttack", 0), libMMAP_gv_aVMechanics[lv_enemyTeamOfEventPlayer_c].lv_flagDummyLockUnit), c_orderQueueReplace);
        }

    }

    if ((UnitGroupCount(libMMAP_gv_aVMechanics[lv_teamOfEventPlayer_c].lv_flagEnemiesCapturingUnitGroup, c_unitCountAlive) <= 0)) {
        UnitRemove(libMMAP_gv_aVMechanics[lv_teamOfEventPlayer_c].lv_flagBeingCapturedUnit);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libMMAP_gt_PlayerStartsChannelMacguffin_Init () {
    libMMAP_gt_PlayerStartsChannelMacguffin = TriggerCreate("libMMAP_gt_PlayerStartsChannelMacguffin_Func");
    TriggerEnable(libMMAP_gt_PlayerStartsChannelMacguffin, false);
    TriggerAddEventPlayerEffectUsed(libMMAP_gt_PlayerStartsChannelMacguffin, c_playerAny, "CaptureMacGuffin");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Player Completes Channel Macguffin
//--------------------------------------------------------------------------------------------------
bool libMMAP_gt_PlayerCompletesChannelMacguffin_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_teamOfEventPlayer_c;
    int lv_enemyTeamOfEventPlayer_c;
    unit lv_eventEffectTarget_c;
    int lv_i;

    // Automatic Variable Declarations
    int autoA9A9861F_ae;
    const int autoA9A9861F_ai = 1;

    // Variable Initialization
    lv_teamOfEventPlayer_c = libGame_gf_TeamNumberOfPlayer(EventPlayer());
    lv_enemyTeamOfEventPlayer_c = libGame_gf_EnemyTeam(lv_teamOfEventPlayer_c);
    lv_eventEffectTarget_c = EventPlayerEffectUsedUnit(c_effectUnitTarget);

    // Conditions
    if (testConds) {
        if (!(((lv_eventEffectTarget_c == libMMAP_gv_aVMechanics[libGame_gv_teamOrderIndex_C].lv_flag) || (lv_eventEffectTarget_c == libMMAP_gv_aVMechanics[libGame_gv_teamChaosIndex_C].lv_flag)))) {
            return false;
        }
    }

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

    libMMAP_gv_capturingPlayerID[lv_teamOfEventPlayer_c] = EventPlayer();
    if ((libMMAP_gv_aVMechanics[lv_teamOfEventPlayer_c].lv_flagIsCaptured == true) && (lv_eventEffectTarget_c == libMMAP_gv_aVMechanics[lv_teamOfEventPlayer_c].lv_flag)) {
        libMMAP_gv_aVMechanics[lv_teamOfEventPlayer_c].lv_flagIsCaptured = false;
        libMMAP_gv_aVMechanics[lv_teamOfEventPlayer_c].lv_respawnDefenders = false;
        TriggerEnable(libMMAP_gv_aVMechanics[lv_teamOfEventPlayer_c].lv_defenderDeathTracker, false);
        TriggerEnable(libMMAP_gv_aVMechanics[lv_teamOfEventPlayer_c].lv_defenderSpawnTracker, false);
        if ((libMMAP_gv_aVTransmissions.lv_hasPlayedCampRetakenVO[lv_teamOfEventPlayer_c] == false) && (TimerGetRemaining(libMMAP_gv_aVTransmissions.lv_campTransmissionCDTimer) == 0.0)) {
            if ((libMMAP_gv_currentTeamLeader == libGame_gv_teamChaosIndex_C) && (lv_teamOfEventPlayer_c == libGame_gv_teamOrderIndex_C)) {
                libMMAP_gf_AllianceRetakesAllianceCamp();
            }
            else if ((libMMAP_gv_currentTeamLeader == libGame_gv_teamOrderIndex_C) && (lv_teamOfEventPlayer_c == libGame_gv_teamChaosIndex_C)) {
                libMMAP_gf_HordeRetakesHordeCamp();
            }
        }

        autoA9A9861F_ae = libMMAP_gv_defenderCount;
        lv_i = 1;
        for ( ; ( (autoA9A9861F_ai >= 0 && lv_i <= autoA9A9861F_ae) || (autoA9A9861F_ai < 0 && lv_i >= autoA9A9861F_ae) ) ; lv_i += autoA9A9861F_ai ) {
            if ((UnitIsValid(libMMAP_gv_aVMechanics[lv_teamOfEventPlayer_c].lv_defenderUnit[lv_i]) == true)) {
                UnitIssueOrder(libMMAP_gv_aVMechanics[lv_teamOfEventPlayer_c].lv_defenderUnit[lv_i], OrderTargetingPoint(AbilityCommand("attack", 0), RegionRandomPoint(libMMAP_gv_aVMechanics[lv_teamOfEventPlayer_c].lv_region[libMMAP_gv_currentCPIndex])), c_orderQueueReplace);
            }

        }
        libMMAP_gf_SpawnAllDefendersImmediately(lv_teamOfEventPlayer_c);
        RemoveUnitOfInterest(lv_eventEffectTarget_c, "RetakeFlag", libAIAI_gf_ConvertIntegertoGoalTeam(lv_teamOfEventPlayer_c));
        AddUnitOfInterest(lv_eventEffectTarget_c, 500.0, 0.0, "CaptureFlag", libAIAI_gf_ConvertIntegertoGoalTeam(lv_enemyTeamOfEventPlayer_c), 0);
        if ((libMMAP_gv_aVMechanics[lv_enemyTeamOfEventPlayer_c].lv_flagIsCaptured == true)) {
            libMMAP_gf_UpdateTeamIconForTeamCurrentlyWinning(lv_teamOfEventPlayer_c);
        }
        else {
            libMMAP_gf_UpdateTeamIconForTeamCurrentlyWinning(libCore_gv_cOMPUTER_Neutral);
        }
        libMMAP_gf_ShowHideNotificationFrame(3.0, lv_teamOfEventPlayer_c, lv_teamOfEventPlayer_c);
        libMMAP_gf_TeamDoesDoesNotCaptureFlag(lv_enemyTeamOfEventPlayer_c, lv_teamOfEventPlayer_c, false, false);
        TextExpressionSetToken("Param/Expression/lib_MMAP_90D96786", "A", StringExternal("Param/Value/lib_MMAP_8A297E2E"));
        TextExpressionSetToken("Param/Expression/lib_MMAP_90D96786", "B", StringExternal("Param/Value/lib_MMAP_92C3B477"));
        TextTagSetText(libMMAP_gv_aVUI.lv_cageTextTag[lv_enemyTeamOfEventPlayer_c][lv_teamOfEventPlayer_c], TextExpressionAssemble("Param/Expression/lib_MMAP_90D96786"));
        TextExpressionSetToken("Param/Expression/lib_MMAP_1625AB31", "A", StringExternal("Param/Value/lib_MMAP_88D81357"));
        TextExpressionSetToken("Param/Expression/lib_MMAP_1625AB31", "B", StringExternal("Param/Value/lib_MMAP_ACC431E2"));
        TextTagSetText(libMMAP_gv_aVUI.lv_cageTextTag[lv_enemyTeamOfEventPlayer_c][lv_enemyTeamOfEventPlayer_c], TextExpressionAssemble("Param/Expression/lib_MMAP_1625AB31"));
        libNtve_gf_SendActorMessageToUnit(libMMAP_gv_aVMechanics[lv_teamOfEventPlayer_c].lv_flagMinimapIcon, "Signal Default");
        ActorSend(libMMAP_gv_aVMechanics[lv_teamOfEventPlayer_c].lv_flagCaptureDoodadActor[libMMAP_gv_currentCPIndex], "Signal DefaultOn");
        ActorSend(libMMAP_gv_aVMechanics[lv_teamOfEventPlayer_c].lv_flagCaptureDoodadActor[libMMAP_gv_currentCPIndex], "SetPlayerId "+IntToString((libGame_gf_ComputerPlayerInTeam(lv_teamOfEventPlayer_c))));
        UnitSetOwner(libMMAP_gv_aVMechanics[lv_teamOfEventPlayer_c].lv_cageUnit[libMMAP_gv_currentCPIndex], libMMAP_gf_NoVisionComputerPlayerInTeam(lv_teamOfEventPlayer_c), true);
        UnitSetOwner(libMMAP_gv_aVMechanics[lv_teamOfEventPlayer_c].lv_flagMinimapIcon, libMMAP_gf_NoVisionComputerPlayerInTeam(lv_teamOfEventPlayer_c), true);
        UnitIssueOrder(lv_eventEffectTarget_c, Order(AbilityCommand("stop", 0)), c_orderQueueReplace);
    }
    else {
        if ((libMMAP_gv_aVMechanics[lv_enemyTeamOfEventPlayer_c].lv_flagIsCaptured == true)) {
            return true;
        }

        libMMAP_gv_aVMechanics[lv_enemyTeamOfEventPlayer_c].lv_flagIsCaptured = true;
        libMMAP_gf_TeamCapturesFlag(lv_teamOfEventPlayer_c, lv_enemyTeamOfEventPlayer_c);
        if ((libMMAP_gv_aVTransmissions.lv_hasPlayedCampCapturedVO[lv_teamOfEventPlayer_c] == false) && (TimerGetRemaining(libMMAP_gv_aVTransmissions.lv_campTransmissionCDTimer) == 0.0)) {
            if ((libMMAP_gv_currentTeamLeader == libGame_gv_teamOrderIndex_C) && (lv_teamOfEventPlayer_c == libGame_gv_teamOrderIndex_C)) {
                libMMAP_gf_AllianceCapturesHordeCamp();
            }
            else if ((libMMAP_gv_currentTeamLeader == libGame_gv_teamChaosIndex_C) && (lv_teamOfEventPlayer_c == libGame_gv_teamChaosIndex_C)) {
                libMMAP_gf_HordeCapturesAllianceCamp();
            }
        }

        UnitIssueOrder(lv_eventEffectTarget_c, OrderTargetingUnit(AbilityCommand("CapturedSoldierDummyAttack", 0), libMMAP_gv_aVMechanics[lv_teamOfEventPlayer_c].lv_flagDummyLockUnit), c_orderQueueReplace);
        RemoveUnitOfInterest(lv_eventEffectTarget_c, "CaptureFlag", libAIAI_gf_ConvertIntegertoGoalTeam(lv_teamOfEventPlayer_c));
        AddUnitOfInterest(lv_eventEffectTarget_c, 500.0, 0.0, "DefendCapturedFlag", libAIAI_gf_ConvertIntegertoGoalTeam(lv_teamOfEventPlayer_c), 0);
        libMMAP_gf_TeamDoesDoesNotCaptureFlag(lv_teamOfEventPlayer_c, lv_enemyTeamOfEventPlayer_c, true, false);
        libMMAP_gf_ShowHideNotificationFrame(3.0, lv_teamOfEventPlayer_c, lv_enemyTeamOfEventPlayer_c);
        libNtve_gf_SendActorMessageToUnit(libMMAP_gv_aVMechanics[lv_enemyTeamOfEventPlayer_c].lv_flagMinimapIcon, "Signal Captured");
        ActorSend(libMMAP_gv_aVMechanics[lv_enemyTeamOfEventPlayer_c].lv_flagCaptureDoodadActor[libMMAP_gv_currentCPIndex], "Signal BeingCaptured");
        ActorSend(libMMAP_gv_aVMechanics[lv_enemyTeamOfEventPlayer_c].lv_flagCaptureDoodadActor[libMMAP_gv_currentCPIndex], "SetPlayerId "+IntToString((libGame_gf_ComputerPlayerInTeam(lv_teamOfEventPlayer_c))));
        UnitSetOwner(libMMAP_gv_aVMechanics[lv_enemyTeamOfEventPlayer_c].lv_cageUnit[libMMAP_gv_currentCPIndex], libMMAP_gf_NoVisionComputerPlayerInTeam(lv_teamOfEventPlayer_c), true);
        UnitSetOwner(libMMAP_gv_aVMechanics[lv_enemyTeamOfEventPlayer_c].lv_flagMinimapIcon, libMMAP_gf_NoVisionComputerPlayerInTeam(lv_teamOfEventPlayer_c), true);
    }
    libMMAP_gf_UnitNotTargetableForTeam(lv_eventEffectTarget_c, lv_teamOfEventPlayer_c);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMMAP_gt_PlayerCompletesChannelMacguffin_Init () {
    libMMAP_gt_PlayerCompletesChannelMacguffin = TriggerCreate("libMMAP_gt_PlayerCompletesChannelMacguffin_Func");
    TriggerEnable(libMMAP_gt_PlayerCompletesChannelMacguffin, false);
    TriggerAddEventPlayerEffectUsed(libMMAP_gt_PlayerCompletesChannelMacguffin, c_playerAny, "CaptureMacGuffinCastComplete");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Player Interrupts Channel Macguffin
//--------------------------------------------------------------------------------------------------
bool libMMAP_gt_PlayerInterruptsChannelMacguffin_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_eventPlayer;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_eventPlayer = EventPlayer();

    // Conditions
    if (testConds) {
        if (!((((lv_eventPlayer >= 1) && (lv_eventPlayer <= libCore_gv_bALMaxPlayers)) == true))) {
            return false;
        }
    }

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

    libGame_gf_SendMapSpecificAwardEvent(lv_eventPlayer, 1.0, true);
    libMMAP_gv_cageUnlockInterrupts[lv_eventPlayer] += 1;
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMMAP_gt_PlayerInterruptsChannelMacguffin_Init () {
    libMMAP_gt_PlayerInterruptsChannelMacguffin = TriggerCreate("libMMAP_gt_PlayerInterruptsChannelMacguffin_Func");
    TriggerEnable(libMMAP_gt_PlayerInterruptsChannelMacguffin, false);
    TriggerAddEventPlayerEffectUsed(libMMAP_gt_PlayerInterruptsChannelMacguffin, c_playerAny, "CaptureMacGuffinDamageResponsePersistent");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Order Cavalry Spawn Timer Expires
//--------------------------------------------------------------------------------------------------
bool libMMAP_gt_OrderCavalrySpawnTimerExpires_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libMMAP_gf_SpawnCavalryForTeam(libGame_gv_teamOrderIndex_C);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMMAP_gt_OrderCavalrySpawnTimerExpires_Init () {
    libMMAP_gt_OrderCavalrySpawnTimerExpires = TriggerCreate("libMMAP_gt_OrderCavalrySpawnTimerExpires_Func");
    TriggerEnable(libMMAP_gt_OrderCavalrySpawnTimerExpires, false);
    TriggerAddEventTimer(libMMAP_gt_OrderCavalrySpawnTimerExpires, libMMAP_gv_aVMechanics[libGame_gv_teamOrderIndex_C].lv_cavalrySpawnTimer);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Chaos Cavalry Spawn Timer Expires
//--------------------------------------------------------------------------------------------------
bool libMMAP_gt_ChaosCavalrySpawnTimerExpires_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libMMAP_gf_SpawnCavalryForTeam(libGame_gv_teamChaosIndex_C);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMMAP_gt_ChaosCavalrySpawnTimerExpires_Init () {
    libMMAP_gt_ChaosCavalrySpawnTimerExpires = TriggerCreate("libMMAP_gt_ChaosCavalrySpawnTimerExpires_Func");
    TriggerEnable(libMMAP_gt_ChaosCavalrySpawnTimerExpires, false);
    TriggerAddEventTimer(libMMAP_gt_ChaosCavalrySpawnTimerExpires, libMMAP_gv_aVMechanics[libGame_gv_teamChaosIndex_C].lv_cavalrySpawnTimer);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Chaos Reward Death Tracker
//--------------------------------------------------------------------------------------------------
bool libMMAP_gt_ChaosRewardDeathTracker_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libMMAP_gf_TeamsRewardUnitDies(libGame_gv_teamChaosIndex_C);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMMAP_gt_ChaosRewardDeathTracker_Init () {
    libMMAP_gt_ChaosRewardDeathTracker = TriggerCreate("libMMAP_gt_ChaosRewardDeathTracker_Func");
    TriggerEnable(libMMAP_gt_ChaosRewardDeathTracker, false);
    TriggerAddEventUnitDied(libMMAP_gt_ChaosRewardDeathTracker, UnitRefFromVariable("libMMAP_gv_aVMechanics[libGame_gv_teamChaosIndex_C].lv_cavalryUnit[libMMAP_ge_AVLanes_Top]"));
    TriggerAddEventUnitDied(libMMAP_gt_ChaosRewardDeathTracker, UnitRefFromVariable("libMMAP_gv_aVMechanics[libGame_gv_teamChaosIndex_C].lv_cavalryUnit[libMMAP_ge_AVLanes_Mid]"));
    TriggerAddEventUnitDied(libMMAP_gt_ChaosRewardDeathTracker, UnitRefFromVariable("libMMAP_gv_aVMechanics[libGame_gv_teamChaosIndex_C].lv_cavalryUnit[libMMAP_ge_AVLanes_Bot]"));
}

//--------------------------------------------------------------------------------------------------
// Trigger: Order Reward Death Tracker
//--------------------------------------------------------------------------------------------------
bool libMMAP_gt_OrderRewardDeathTracker_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libMMAP_gf_TeamsRewardUnitDies(libGame_gv_teamOrderIndex_C);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMMAP_gt_OrderRewardDeathTracker_Init () {
    libMMAP_gt_OrderRewardDeathTracker = TriggerCreate("libMMAP_gt_OrderRewardDeathTracker_Func");
    TriggerEnable(libMMAP_gt_OrderRewardDeathTracker, false);
    TriggerAddEventUnitDied(libMMAP_gt_OrderRewardDeathTracker, UnitRefFromVariable("libMMAP_gv_aVMechanics[libGame_gv_teamOrderIndex_C].lv_cavalryUnit[libMMAP_ge_AVLanes_Top]"));
    TriggerAddEventUnitDied(libMMAP_gt_OrderRewardDeathTracker, UnitRefFromVariable("libMMAP_gv_aVMechanics[libGame_gv_teamOrderIndex_C].lv_cavalryUnit[libMMAP_ge_AVLanes_Mid]"));
    TriggerAddEventUnitDied(libMMAP_gt_OrderRewardDeathTracker, UnitRefFromVariable("libMMAP_gv_aVMechanics[libGame_gv_teamOrderIndex_C].lv_cavalryUnit[libMMAP_ge_AVLanes_Bot]"));
}

//--------------------------------------------------------------------------------------------------
// Trigger: Order Core Takes Damage - Get Hit Sounds
//--------------------------------------------------------------------------------------------------
bool libMMAP_gt_OrderCoreTakesDamageGetHitSounds_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libMMAP_gf_CoreTakesDamagePlayGetHitSound(libGame_gv_teamOrderIndex_C, EventUnitDamageAmount());
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMMAP_gt_OrderCoreTakesDamageGetHitSounds_Init () {
    libMMAP_gt_OrderCoreTakesDamageGetHitSounds = TriggerCreate("libMMAP_gt_OrderCoreTakesDamageGetHitSounds_Func");
    TriggerAddEventUnitDamaged(libMMAP_gt_OrderCoreTakesDamageGetHitSounds, UnitRefFromVariable("libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_core"), c_unitDamageTypeAny, c_unitDamageNonFatal, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Chaos Core Takes Damage - Get Hit Sounds
//--------------------------------------------------------------------------------------------------
bool libMMAP_gt_ChaosCoreTakesDamageGetHitSounds_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libMMAP_gf_CoreTakesDamagePlayGetHitSound(libGame_gv_teamChaosIndex_C, EventUnitDamageAmount());
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMMAP_gt_ChaosCoreTakesDamageGetHitSounds_Init () {
    libMMAP_gt_ChaosCoreTakesDamageGetHitSounds = TriggerCreate("libMMAP_gt_ChaosCoreTakesDamageGetHitSounds_Func");
    TriggerAddEventUnitDamaged(libMMAP_gt_ChaosCoreTakesDamageGetHitSounds, UnitRefFromVariable("libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_core"), c_unitDamageTypeAny, c_unitDamageNonFatal, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Player Gains Slow From Snow
//--------------------------------------------------------------------------------------------------
bool libMMAP_gt_PlayerGainsSlowFromSnow_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_player;
    int lv_unitIndex;

    // Automatic Variable Declarations
    unitgroup auto3B97AC04_g;
    int auto3B97AC04_u;
    unit auto3B97AC04_var;

    // Variable Initialization
    lv_player = UnitGetOwner(EventUnit());

    // Conditions
    if (testConds) {
        if (!((lv_player >= 1))) {
            return false;
        }

        if (!((lv_player <= libCore_gv_bALMaxPlayers))) {
            return false;
        }

        if (!((libGame_gf_UnitIsHero(EventUnit()) == true))) {
            return false;
        }
    }

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

    auto3B97AC04_g = libGame_gv_players[lv_player].lv_heroUnitGroup;
    auto3B97AC04_u = UnitGroupCount(auto3B97AC04_g, c_unitCountAll);
    for (;; auto3B97AC04_u -= 1) {
        auto3B97AC04_var = UnitGroupUnitFromEnd(auto3B97AC04_g, auto3B97AC04_u);
        if (auto3B97AC04_var == null) { break; }
        lv_unitIndex += 1;
        if ((EventUnit() == auto3B97AC04_var)) {
            break;
        }

    }
    SoundPlayOnUnitForPlayer(SoundLink("Gen_Spell_Slow_Loop_PLR", -1), lv_player, PlayerGroupSingle(lv_player), EventUnit(), 0.0, 100.0, 0.0);
    libMMAP_gv_aVSounds.lv_snowSound[lv_player][lv_unitIndex] = SoundLastPlayed();
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMMAP_gt_PlayerGainsSlowFromSnow_Init () {
    libMMAP_gt_PlayerGainsSlowFromSnow = TriggerCreate("libMMAP_gt_PlayerGainsSlowFromSnow_Func");
    TriggerAddEventUnitBehaviorChange(libMMAP_gt_PlayerGainsSlowFromSnow, null, "SnowDriftSlowMonitor", c_unitBehaviorChangeCreate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Player Loses Slow From Snow
//--------------------------------------------------------------------------------------------------
bool libMMAP_gt_PlayerLosesSlowFromSnow_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_player;
    int lv_unitIndex;

    // Automatic Variable Declarations
    unitgroup auto846C9813_g;
    int auto846C9813_u;
    unit auto846C9813_var;

    // Variable Initialization
    lv_player = UnitGetOwner(EventUnit());

    // Conditions
    if (testConds) {
        if (!((lv_player >= 1))) {
            return false;
        }

        if (!((lv_player <= libCore_gv_bALMaxPlayers))) {
            return false;
        }

        if (!((libGame_gf_UnitIsHero(EventUnit()) == true))) {
            return false;
        }
    }

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

    auto846C9813_g = libGame_gv_players[lv_player].lv_heroUnitGroup;
    auto846C9813_u = UnitGroupCount(auto846C9813_g, c_unitCountAll);
    for (;; auto846C9813_u -= 1) {
        auto846C9813_var = UnitGroupUnitFromEnd(auto846C9813_g, auto846C9813_u);
        if (auto846C9813_var == null) { break; }
        lv_unitIndex += 1;
        if ((EventUnit() == auto846C9813_var)) {
            break;
        }

    }
    SoundStop(libMMAP_gv_aVSounds.lv_snowSound[lv_player][lv_unitIndex], true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMMAP_gt_PlayerLosesSlowFromSnow_Init () {
    libMMAP_gt_PlayerLosesSlowFromSnow = TriggerCreate("libMMAP_gt_PlayerLosesSlowFromSnow_Func");
    TriggerAddEventUnitBehaviorChange(libMMAP_gt_PlayerLosesSlowFromSnow, null, "SnowDriftSlowMonitor", c_unitBehaviorChangeDestroy);
}

void libMMAP_InitTriggers () {
    libMMAP_gt_IncludeModInit_Init();
    libMMAP_gt_DEBUG_Help_Init();
    libMMAP_gt_DEBUG_SendEnemyMapMechanicReward_Init();
    libMMAP_gt_DEBUG_ToggleDefenders_Init();
    libMMAP_gt_DEBUG_EventStart_Init();
    libMMAP_gt_DEBUG_EventStartFast_Init();
    libMMAP_gt_DEBUG_MakeAlliedFlagsTargetable_Init();
    libMMAP_gt_GameOpenTimerStarted_Init();
    libMMAP_gt_OpenTheGatesTimerExpires_Init();
    libMMAP_gt_EventObjectivePreviewTimerExpires_Init();
    libMMAP_gt_EventWarningTimerExpires_Init();
    libMMAP_gt_EventTimerExpires_Init();
    libMMAP_gt_GameOver_Init();
    libMMAP_gt_TownStructureDiesRemoveBossArmor_Init();
    libMMAP_gt_OrderDefenderSpawnTimerExpires_Init();
    libMMAP_gt_ChaosDefenderSpawnTimerExpires_Init();
    libMMAP_gt_OrderDefenderDies_Init();
    libMMAP_gt_ChaosDefenderDies_Init();
    libMMAP_gt_DEBUG_WatchDefenderAi_Init();
    libMMAP_gt_PlayerStartsChannelMacguffin_Init();
    libMMAP_gt_PlayerCompletesChannelMacguffin_Init();
    libMMAP_gt_PlayerInterruptsChannelMacguffin_Init();
    libMMAP_gt_OrderCavalrySpawnTimerExpires_Init();
    libMMAP_gt_ChaosCavalrySpawnTimerExpires_Init();
    libMMAP_gt_ChaosRewardDeathTracker_Init();
    libMMAP_gt_OrderRewardDeathTracker_Init();
    libMMAP_gt_OrderCoreTakesDamageGetHitSounds_Init();
    libMMAP_gt_ChaosCoreTakesDamageGetHitSounds_Init();
    libMMAP_gt_PlayerGainsSlowFromSnow_Init();
    libMMAP_gt_PlayerLosesSlowFromSnow_Init();
}

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

void libMMAP_InitLib () {
    if (libMMAP_InitLib_completed) {
        return;
    }

    libMMAP_InitLib_completed = true;

    libMMAP_InitLibraries();
    libMMAP_InitVariables();
    libMMAP_InitTriggers();
}