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();

}