mods/heroesmapmods/battlegroundmapmods/gardenofterror_classic.stormmod/base.stormdata/libmdnc.galaxy

libmdnc.galaxy
include "TriggerLibs/NativeLib"
include "TriggerLibs/HeroesLib"
include "TriggerLibs/GameLib"
include "TriggerLibs/MapMechanicsLib"
include "TriggerLibs/AILib"
include "TriggerLibs/UILib"
include "TriggerLibs/SoundLib"
include "TriggerLibs/GameDataHelperLib"

include "LibMDNC_h"

//--------------------------------------------------------------------------------------------------
// Library: Garden of Terror
//--------------------------------------------------------------------------------------------------
// External Library Initialization
void libMDNC_InitLibraries () {
    libNtve_InitVariables();
    libCore_InitVariables();
    libGame_InitVariables();
    libMapM_InitVariables();
    libAIAI_InitVariables();
    libUIUI_InitVariables();
    libSond_InitVariables();
    libGDHL_InitVariables();
}

// Variable Initialization
bool libMDNC_InitVariables_completed = false;

void libMDNC_InitVariables () {
    int init_i;
    int init_i1;

    if (libMDNC_InitVariables_completed) {
        return;
    }

    libMDNC_InitVariables_completed = true;

    for (init_i = 0; init_i <= 10; init_i += 1) {
        libMDNC_gv_mMGardenTerrorNightMinionGroups[init_i].lv_units = UnitGroupEmpty();
    }
    libMDNC_gv_mMGardenTerrorNightMonsters = UnitGroupEmpty();
    for (init_i = 0; init_i <= 2; init_i += 1) {
        for (init_i1 = 0; init_i1 <= 2; init_i1 += 1) {
            libMDNC_gv_mMGardenTerrorGarden[init_i].lv_ping[init_i1] = c_invalidPingId;
        }
        libMDNC_gv_mMGardenTerrorGarden[init_i].lv_summonPing = c_invalidPingId;
        for (init_i1 = 0; init_i1 <= libCore_gv_bALMaxPlayers; init_i1 += 1) {
            libMDNC_gv_mMGardenTerrorGarden[init_i].lv_hintTextTag[init_i1] = c_textTagNone;
        }
    }
    libMDNC_gv_mMGardenTerrorVehicleChannelTime_C = 2.0;
    libMDNC_gv_mMGardenTerrorOpenFirstTime = true;
    libMDNC_gv_mMGardenTerrorPrepTimer = TimerCreate();
    libMDNC_gv_mMGardenTerrorNightTimer = TimerCreate();
    libMDNC_gv_mMGardenTerrorCampsHibernateState = libMDNC_ge_MMGardenTerrorCampHibernateState_None;
    for (init_i = 0; init_i <= 2; init_i += 1) {
        libMDNC_gv_mMGardenTerrorHintTextTag[init_i] = c_textTagNone;
    }
    for (init_i = 0; init_i <= libCore_gv_bALMaxTeams; init_i += 1) {
        libMDNC_gv_mMGardenTerrorGolemCooldownTimer[init_i] = TimerCreate();
    }
    libMDNC_gv_mMGardenTerrorTransmissionNightStartsWarningFirstTime = true;
    libMDNC_gv_mMGardenTerrorOvergrowthSelfHealthDecay_C = 7.0;
    libMDNC_gv_vehiclePlantHorrorDamageReduction = 0.25;
    libMDNC_gv_nightMinionActiveGroup = UnitGroupEmpty();
}

// Presets
// Functions
void libMDNC_gf_MMGardenTerrorAddNightMinionInfo (region lp_groupArea, unit lp_bannerSconceUnit) {
    // Variable Declarations
    int lv_groupIndex;
    unit lv_itMinion;
    int lv_minionIndex;
    int lv_itCamp;

    // Automatic Variable Declarations
    unitgroup autoE6E433FA_g;
    int autoE6E433FA_u;
    int autoBD959E00_ae;
    const int autoBD959E00_ai = 1;

    // Variable Initialization

    // Implementation
    libMDNC_gv_mMGardenTerrorNightMinionGroupsCount += 1;
    lv_groupIndex = libMDNC_gv_mMGardenTerrorNightMinionGroupsCount;
    libMDNC_gv_mMGardenTerrorNightMinionGroups[lv_groupIndex].lv_area = lp_groupArea;
    libMDNC_gv_mMGardenTerrorNightMinionGroups[lv_groupIndex].lv_bannerSconce = lp_bannerSconceUnit;
    autoE6E433FA_g = UnitGroup(null, libCore_gv_cOMPUTER_Hostile, lp_groupArea, UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    autoE6E433FA_u = UnitGroupCount(autoE6E433FA_g, c_unitCountAll);
    for (;; autoE6E433FA_u -= 1) {
        lv_itMinion = UnitGroupUnitFromEnd(autoE6E433FA_g, autoE6E433FA_u);
        if (lv_itMinion == null) { break; }
        libMDNC_gv_mMGardenTerrorNightMinionGroups[lv_groupIndex].lv_minionCount += 1;
        lv_minionIndex = libMDNC_gv_mMGardenTerrorNightMinionGroups[lv_groupIndex].lv_minionCount;
        libMDNC_gv_mMGardenTerrorNightMinionGroups[lv_groupIndex].lv_minionType[lv_minionIndex] = UnitGetType(lv_itMinion);
        libMDNC_gv_mMGardenTerrorNightMinionGroups[lv_groupIndex].lv_positions[lv_minionIndex] = UnitGetPosition(lv_itMinion);
        PointSetFacing(libMDNC_gv_mMGardenTerrorNightMinionGroups[lv_groupIndex].lv_positions[lv_minionIndex], UnitGetFacing(lv_itMinion));
        UnitRemove(lv_itMinion);
    }
    libMDNC_gv_mMGardenTerrorNightMinionGroups[lv_groupIndex].lv_units = UnitGroupEmpty();
    autoBD959E00_ae = libMapM_gv_jungleNumberOfCreepCamps;
    lv_itCamp = 1;
    for ( ; ( (autoBD959E00_ai >= 0 && lv_itCamp <= autoBD959E00_ae) || (autoBD959E00_ai < 0 && lv_itCamp >= autoBD959E00_ae) ) ; lv_itCamp += autoBD959E00_ai ) {
        if ((DistanceBetweenPoints(libMapM_gv_jungleCreepCamps[lv_itCamp].lv_mapDataCampCaptainSpawnPoint, RegionGetCenter(libMDNC_gv_mMGardenTerrorNightMinionGroups[lv_groupIndex].lv_area)) <= 6.0)) {
            libMDNC_gv_mMGardenTerrorNightMinionGroups[lv_groupIndex].lv_camp = lv_itCamp;
            break;
        }

    }
}

void libMDNC_gf_MMGardenTerrorAddNightBoss (region lp_groupArea, unit lp_bannerSconceUnit) {
    // Variable Declarations
    int lv_index;
    unit lv_boss;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    lv_boss = UnitGroupUnit(UnitGroup("JunglePlantHorror", libCore_gv_cOMPUTER_Hostile, lp_groupArea, UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 1), 1);
    if ((lv_boss != null)) {
        libMDNC_gv_mMGardenTerrorNightBossesCount += 1;
        lv_index = libMDNC_gv_mMGardenTerrorNightBossesCount;
        libMDNC_gv_mMGardenTerrorNightBosses[lv_index].lv_area = lp_groupArea;
        libMDNC_gv_mMGardenTerrorNightBosses[lv_index].lv_bannerSconce = lp_bannerSconceUnit;
        libMDNC_gv_mMGardenTerrorNightBosses[lv_index].lv_positions = UnitGetPosition(lv_boss);
        PointSetFacing(libMDNC_gv_mMGardenTerrorNightBosses[lv_index].lv_positions, UnitGetFacing(lv_boss));
        UnitRemove(lv_boss);
        libMDNC_gv_mMGardenTerrorNightBosses[lv_index].lv_unit = null;
    }

}

void libMDNC_gf_MMGardenTerrorAddGarden (point lp_gardenOrder, region lp_gardenAreaOrder, point lp_gardenChaos, region lp_gardenAreaChaos, unit lp_gardenFertileSoilOrder, unit lp_gardenFertileSoilChaos) {
    // Automatic Variable Declarations
    // Implementation
    libMDNC_gv_mMGardenTerrorGarden[libGame_gv_teamOrderIndex_C].lv_positions = lp_gardenOrder;
    libMDNC_gv_mMGardenTerrorGarden[libGame_gv_teamOrderIndex_C].lv_facing = PointGetFacing(lp_gardenOrder);
    libMDNC_gv_mMGardenTerrorGarden[libGame_gv_teamOrderIndex_C].lv_region = lp_gardenAreaOrder;
    libMDNC_gv_mMGardenTerrorGarden[libGame_gv_teamOrderIndex_C].lv_fertileSoil = lp_gardenFertileSoilOrder;
    libMDNC_gv_mMGardenTerrorGarden[libGame_gv_teamChaosIndex_C].lv_positions = lp_gardenChaos;
    libMDNC_gv_mMGardenTerrorGarden[libGame_gv_teamChaosIndex_C].lv_facing = PointGetFacing(lp_gardenChaos);
    libMDNC_gv_mMGardenTerrorGarden[libGame_gv_teamChaosIndex_C].lv_region = lp_gardenAreaChaos;
    libMDNC_gv_mMGardenTerrorGarden[libGame_gv_teamChaosIndex_C].lv_fertileSoil = lp_gardenFertileSoilChaos;
}

void libMDNC_gf_MMGardenTerrorAddZombieWalkerSpawnInfo (int lp_groupArea3, point lp_groupArea, point lp_groupArea2) {
    // Automatic Variable Declarations
    // Implementation
    libMDNC_gv_mMGardenTerrorSpawnInfo[lp_groupArea3].lv_spawnPoint = lp_groupArea;
    libMDNC_gv_mMGardenTerrorSpawnInfo[lp_groupArea3].lv_goalPoint = lp_groupArea2;
}

void libMDNC_gf_MMGardenTerrorNightPrepare () {
    // Automatic Variable Declarations
    // Implementation
    TriggerEnable(libMDNC_gt_MMGardenTerrorGatesOpened, false);
    TriggerExecute(libMDNC_gt_MMGardenTerrorUIHandler, true, false);
    if ((libMDNC_gv_mMGardenTerrorTransmissionNightStartsWarningFirstTime == true)) {
        libMDNC_gv_mMGardenTerrorTransmissionNightStartsWarningFirstTime = false;
        libMDNC_gf_MMDragonballsTransmissionDragonExpireQ2();
    }
    else {
        libMDNC_gf_MMDragonballsTransmissionDragonExpireQ3();
    }
    libMDNC_gv_mMGardenTerrorNightTimes += 1;
    TimerStart(libMDNC_gv_mMGardenTerrorPrepTimer, libMDNC_gv_mMGardenTerrorNightStartsWarningDuration_C, false, c_timeGame);
    SoundPlayForPlayer(SoundLink("Event_GardenOfTerror_Night_Countdown", -1), c_maxPlayers, PlayerGroupAll(), 100.0, 0.0);
}

trigger auto_libMDNC_gf_MMGardenTerrorNightStarts_Trigger = null;

void libMDNC_gf_MMGardenTerrorNightStarts () {
    if (auto_libMDNC_gf_MMGardenTerrorNightStarts_Trigger == null) {
        auto_libMDNC_gf_MMGardenTerrorNightStarts_Trigger = TriggerCreate("auto_libMDNC_gf_MMGardenTerrorNightStarts_TriggerFunc");
    }

    TriggerExecute(auto_libMDNC_gf_MMGardenTerrorNightStarts_Trigger, false, false);
}

bool auto_libMDNC_gf_MMGardenTerrorNightStarts_TriggerFunc (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_itPlayer;
    int lv_itGarden;
    int lv_itTeam;

    // Automatic Variable Declarations
    const int autoFFD3E13F_ae = 2;
    const int autoFFD3E13F_ai = 1;

    // Variable Initialization

    // Implementation
    libMDNC_gv_mMGardenTerrorNightFallen = true;
    if ((libMDNC_gv_mMGardenTerrorOpenFirstTime == true)) {
        libMDNC_gv_mMGardenTerrorOpenFirstTime = false;
        libMDNC_gf_MMDragonballsTransmissionDragonExpireQ5();
    }
    else {
        libMDNC_gf_MMDragonballsTransmissionDragonExpireQ4();
    }
    libMDNC_gv_mMGardenTerrorSeedsCollectedTonight[1] = 0;
    libMDNC_gv_mMGardenTerrorSeedsCollectedTonight[2] = 0;
    libGame_gf_SendEventMapGardenOfTerrorNightStarts();
    ActorSend(libMapM_gv_mapMechanicControllerActor, "Signal MM1On");
    libMDNC_gf_MMGardenTerrorUpdateCampHibernating();
    libCore_gf_DataAnnouncerVOSetDefaultAnnouncerForPlayerGroup(PlayerGroupAll(), "GardensNightAnnouncer");
    TriggerExecute(libMDNC_gt_MMGardenTerrorNightStartLightTransition, true, false);
    libCore_gv_mAPMapSoundtrack[1] = "MX_GardenOfTerror_Night_LVL_1";
    libCore_gv_mAPMapSoundtrack[2] = "MX_GardenOfTerror_Night_LVL_10";
    libCore_gv_mAPMapSoundtrack[3] = "MX_GardenOfTerror_Night_LVL_20";
    SoundtrackStop(PlayerGroupAll(), c_soundtrackCategoryMusic, true);
    libSond_gf_SoundtrackPlayMapSoundtrackAsDefaultSoundtrackForAllPlayers();
    SoundtrackPlay(PlayerGroupAll(), c_soundtrackCategoryAmbience, "Amb_2D_GardenOfTerror_Night", c_soundtrackCueAny, c_soundtrackIndexAny, true);
    ActorCreate(ActorScopeFromActor(libMapM_gv_mapMechanicControllerActor), "Amb_Group_GardenOfTerror_Day2Night", null, null, null);
    SoundChannelMute(PlayerGroupAll(), c_soundCategoryUser14, false);
    SoundChannelMute(PlayerGroupAll(), c_soundCategorySPieces, true);
    SoundChannelMute(PlayerGroupAll(), c_soundCategoryMessage, true);
    TriggerExecute(libMDNC_gt_MMGardenTerrorNightVignette, true, false);
    TriggerEnable(libMDNC_gt_MMGardenTerrorPlantDamageCalculation, true);
    libMDNC_gf_MMGardenTerrorSpawnNightMonsters();
    Wait(1.5, c_timeGame);
    lv_itTeam = 1;
    for ( ; ( (autoFFD3E13F_ai >= 0 && lv_itTeam <= autoFFD3E13F_ae) || (autoFFD3E13F_ai < 0 && lv_itTeam >= autoFFD3E13F_ae) ) ; lv_itTeam += autoFFD3E13F_ai ) {
        libNtve_gf_SendActorMessageToUnit(libMDNC_gv_mMGardenTerrorGarden[lv_itTeam].lv_units, "Signal NightStarts");
        libMDNC_gf_MMGardenTerrorUpdateHauntedGarden(lv_itTeam);
        if ((libMDNC_gv_mMGardenTerrorGarden[lv_itTeam].lv_gardenLight == null)) {
            libNtve_gf_CreateModelAtPoint("UnderworldHeroLightOther", libMDNC_gv_mMGardenTerrorGarden[lv_itTeam].lv_positions);
            libMDNC_gv_mMGardenTerrorGarden[lv_itTeam].lv_gardenLight = libNtve_gf_ActorLastCreated();
        }

    }
    return true;
}

void libMDNC_gf_MMGardenTerrorNightEnds () {
    // Variable Declarations
    int lv_itPlayer;
    int lv_itGroupIndex;
    unit lv_itMinion;
    int lv_itTeam;

    // Automatic Variable Declarations
    const int autoBA47F749_ae = 2;
    const int autoBA47F749_ai = 1;
    int autoA23FFAC2_ae;
    const int autoA23FFAC2_ai = 1;
    unitgroup autoA705CF6F_g;
    int autoA705CF6F_u;
    int autoD4F10144_ae;
    const int autoD4F10144_ai = 1;

    // Variable Initialization

    // Implementation
    if ((libMDNC_gv_mMGardenTerrorNightFallen == false)) {
        return ;
    }

    libMDNC_gf_MMGardenTerrorTransmissionNightEndsQ();
    TriggerEnable(libMDNC_gt_MMGardenTerrorPlantDamageCalculation, false);
    libGame_gf_SpecialLightingEventEnd("Storm_RavenCourt_Curse", PlayerGroupAll(), 1.0);
    libMDNC_gv_mMGardenTerrorNightFallen = false;
    ActorSend(libMapM_gv_mapMechanicControllerActor, "Signal MM1Off");
    libCore_gf_DataAnnouncerVOSetDefaultAnnouncerForPlayerGroup(PlayerGroupAll(), "GardensDayAnnouncer");
    TriggerExecute(libMDNC_gt_MMGardenTerrorNightEndLightTransition, true, false);
    libUIUI_gf_VignetteOverlayStopForAllPlayersExcludingSpecifiedPlayerGroup(PlayerGroupEmpty());
    SoundChannelMute(PlayerGroupAll(), c_soundCategoryUser14, true);
    SoundChannelMute(PlayerGroupAll(), c_soundCategorySPieces, false);
    SoundChannelMute(PlayerGroupAll(), c_soundCategoryMessage, false);
    lv_itTeam = 1;
    for ( ; ( (autoBA47F749_ai >= 0 && lv_itTeam <= autoBA47F749_ae) || (autoBA47F749_ai < 0 && lv_itTeam >= autoBA47F749_ae) ) ; lv_itTeam += autoBA47F749_ai ) {
        libNtve_gf_SendActorMessageToUnit(libMDNC_gv_mMGardenTerrorSummonedBoss[lv_itTeam], "Signal NightEnds");
        if ((libMDNC_gv_mMGardenTerrorGarden[lv_itTeam].lv_gardenLight != null)) {
            ActorSend(libMDNC_gv_mMGardenTerrorGarden[lv_itTeam].lv_gardenLight, "Destroy Immediate");
            libMDNC_gv_mMGardenTerrorGarden[lv_itTeam].lv_gardenLight = null;
        }

    }
    libCore_gv_mAPMapSoundtrack[1] = "MX_GardenOfTerror_Day_LVL_1";
    libCore_gv_mAPMapSoundtrack[2] = "MX_GardenOfTerror_Day_LVL_10";
    libCore_gv_mAPMapSoundtrack[3] = "MX_GardenOfTerror_Day_LVL_20";
    libSond_gf_SoundtrackPlayMapSoundtrackAsDefaultSoundtrackForAllPlayers();
    SoundPlayForPlayer(SoundLink("Event_GardenOfTerror_Transition_Night2Day", -1), c_maxPlayers, PlayerGroupAll(), 100.0, 0.0);
    SoundtrackPlay(PlayerGroupAll(), c_soundtrackCategoryAmbience, "Amb_2D_GardenOfTerror_Day", c_soundtrackCueAny, c_soundtrackIndexAny, false);
    ActorCreate(ActorScopeFromActor(libMapM_gv_mapMechanicControllerActor), "Amb_Group_GardenOfTerror_Night2Day", null, null, null);
    libMDNC_gf_MMGardenTerrorUpdateCampHibernating();
    libMDNC_gv_mMGardenTerrorDays += 1;
    autoA23FFAC2_ae = libMDNC_gv_mMGardenTerrorNightMinionGroupsCount;
    lv_itGroupIndex = 1;
    for ( ; ( (autoA23FFAC2_ai >= 0 && lv_itGroupIndex <= autoA23FFAC2_ae) || (autoA23FFAC2_ai < 0 && lv_itGroupIndex >= autoA23FFAC2_ae) ) ; lv_itGroupIndex += autoA23FFAC2_ai ) {
        autoA705CF6F_g = libMDNC_gv_mMGardenTerrorNightMinionGroups[lv_itGroupIndex].lv_units;
        autoA705CF6F_u = UnitGroupCount(autoA705CF6F_g, c_unitCountAll);
        for (;; autoA705CF6F_u -= 1) {
            lv_itMinion = UnitGroupUnitFromEnd(autoA705CF6F_g, autoA705CF6F_u);
            if (lv_itMinion == null) { break; }
            if ((UnitTestState(lv_itMinion, c_unitStateIdle) == true) && (UnitIsAlive(lv_itMinion) == true)) {
                UnitRemove(lv_itMinion);
            }
            else {
                UnitGroupAdd(libMDNC_gv_nightMinionActiveGroup, lv_itMinion);
            }
        }
    }
    autoD4F10144_ae = libMDNC_gv_mMGardenTerrorNightBossesCount;
    lv_itGroupIndex = 1;
    for ( ; ( (autoD4F10144_ai >= 0 && lv_itGroupIndex <= autoD4F10144_ae) || (autoD4F10144_ai < 0 && lv_itGroupIndex >= autoD4F10144_ae) ) ; lv_itGroupIndex += autoD4F10144_ai ) {
        libMDNC_gf_MMGardenTerrorNightEndsRemoveBoss(lv_itGroupIndex);
    }
    Wait((libMDNC_gv_mMGardenTerrorDayDuration_C - libMDNC_gv_mMGardenTerrorNightStartsWarningDuration_C), c_timeGame);
    libMDNC_gf_MMGardenTerrorNightPrepare();
}

trigger auto_libMDNC_gf_MMGardenTerrorNightEndsRemoveBoss_Trigger = null;
int auto_libMDNC_gf_MMGardenTerrorNightEndsRemoveBoss_lp_bossIndex;

void libMDNC_gf_MMGardenTerrorNightEndsRemoveBoss (int lp_bossIndex) {
    auto_libMDNC_gf_MMGardenTerrorNightEndsRemoveBoss_lp_bossIndex = lp_bossIndex;

    if (auto_libMDNC_gf_MMGardenTerrorNightEndsRemoveBoss_Trigger == null) {
        auto_libMDNC_gf_MMGardenTerrorNightEndsRemoveBoss_Trigger = TriggerCreate("auto_libMDNC_gf_MMGardenTerrorNightEndsRemoveBoss_TriggerFunc");
    }

    TriggerExecute(auto_libMDNC_gf_MMGardenTerrorNightEndsRemoveBoss_Trigger, false, false);
}

bool auto_libMDNC_gf_MMGardenTerrorNightEndsRemoveBoss_TriggerFunc (bool testConds, bool runActions) {
    int lp_bossIndex = auto_libMDNC_gf_MMGardenTerrorNightEndsRemoveBoss_lp_bossIndex;

    // Variable Declarations
    unit lv_boss;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    lv_boss = libMDNC_gv_mMGardenTerrorNightBosses[lp_bossIndex].lv_unit;
    while (true) {
        if ((UnitIsAlive(lv_boss) == false)) {
            break;
        }

        if (((libAIAI_gf_DefendersAreFighting(libAIAI_gf_DefenderAIIndexOfUnit(lv_boss)) == false) || (libAIAI_gf_DefendersAreLeashing(libAIAI_gf_DefenderAIIndexOfUnit(lv_boss)) == false))) {
            break;
        }

        Wait(0.5, c_timeGame);
    }
    if ((UnitIsAlive(libMDNC_gv_mMGardenTerrorNightBosses[lp_bossIndex].lv_unit) == true)) {
        UnitRemove(libMDNC_gv_mMGardenTerrorNightBosses[lp_bossIndex].lv_unit);
        libMDNC_gv_mMGardenTerrorNightBosses[lp_bossIndex].lv_unit = null;
    }

    return true;
}

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

    // Automatic Variable Declarations
    const int auto2087C410_ae = 2;
    const int auto2087C410_ai = 1;

    // Variable Initialization

    // Implementation
    lv_itTeam = 1;
    for ( ; ( (auto2087C410_ai >= 0 && lv_itTeam <= auto2087C410_ae) || (auto2087C410_ai < 0 && lv_itTeam >= auto2087C410_ae) ) ; lv_itTeam += auto2087C410_ai ) {
        libMDNC_gf_MMGardenTerrorCreateHauntedGarden(lv_itTeam, false);
    }
}

void libMDNC_gf_MMGardenTerrorCreateHauntedGarden (int lp_team, bool lp_respawn) {
    // Variable Declarations
    int lv_player;
    int lv_itPlayer;

    // Automatic Variable Declarations
    playergroup autoD248749D_g;

    // Variable Initialization

    // Implementation
    if ((libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_units != null)) {

    }

    if ((lp_respawn == true)) {
        ActorSend(libNtve_gf_MainActorofUnit(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_fertileSoil), "Signal Respawn");
        Wait(1.0, c_timeGame);
    }

    lv_player = libGame_gf_ComputerPlayerInTeam(lp_team);
    UnitCreate(1, "VehiclePlantHorror", c_unitCreateIgnorePlacement, lv_player, libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_positions, libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_facing, null);
    libMapM_gf_AddVehicle(UnitLastCreated());
    libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_units = UnitLastCreated();
    if ((libMDNC_gv_mMGardenTerrorNightFallen == true)) {
        libNtve_gf_SendActorMessageToUnit(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_units, "StatusSet Night 1");
    }
    else {
        libNtve_gf_SendActorMessageToUnit(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_units, "StatusSet Night 0");
    }
    libNtve_gf_SendActorMessageToUnit(UnitLastCreated(), "SetMinimapVisibility");
    libNtve_gf_SendActorMessageToUnit(UnitLastCreated(), "Signal AddSeedGrowth3");
    libNtve_gf_MakeUnitInvulnerable(UnitLastCreated(), true);
    UnitCreate(1, "JungleCampIconUnitTeamColor", c_unitCreateIgnorePlacement, UnitGetOwner(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_units), UnitGetPosition(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_units), UnitGetFacing(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_units), null);
    libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_pingUnit = UnitLastCreated();
    libNtve_gf_MakeUnitInvulnerable(UnitLastCreated(), true);
    libNtve_gf_SendActorMessageToUnit(UnitLastCreated(), "MinimapIcon Assets\\Textures\\storm_ui_minimapicon_gardenfertilesoil.dds");
    libNtve_gf_SendActorMessageToUnit(UnitLastCreated(), "MinimapTooltip Unit/Name/FertileSoil");
    libNtve_gf_SendActorMessageToUnit(UnitLastCreated(), "MinimapIconScale 0.650000");
    libNtve_gf_SendActorMessageToUnit(UnitLastCreated(), "SetMinimapVisibilityAlways 1");
    UnitSetInfoText(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_units, StringToText(""), StringExternal("Param/Value/lib_MDNC_A8F69647"), StringToText(""));
    UnitSetState(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_units, c_unitStateTooltipable, true);
    autoD248749D_g = libGame_gf_PlayersOnTeamHeroes(lp_team, false);
    lv_itPlayer = -1;
    while (true) {
        	lv_itPlayer = PlayerGroupNextPlayer(autoD248749D_g, lv_itPlayer);
        	if (lv_itPlayer<0) { break; }
        	if ((libMDNC_gv_mMGardenTerrorPlayerSummoned[lv_itPlayer] == false) && (libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_hintTextTag[lv_itPlayer] == c_textTagNone)) {
            TextTagCreate(StringExternal("Param/Value/lib_MDNC_EF39C23E"), 24, UnitGetPosition(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_units), 1.0, true, false, PlayerGroupAll());
            libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_hintTextTag[lv_itPlayer] = TextTagLastCreated();
            TextTagShow(TextTagLastCreated(), PlayerGroupAll(), false);
            TextTagShow(TextTagLastCreated(), libCore_gv_playerGroupFromPlayer[lv_itPlayer], true);
        }

    }
    libMDNC_gf_MMGardenTerrorUpdateHauntedGarden(lp_team);
}

trigger auto_libMDNC_gf_MMGardenTerrorUpdateHauntedGarden_Trigger = null;
int auto_libMDNC_gf_MMGardenTerrorUpdateHauntedGarden_lp_team;

void libMDNC_gf_MMGardenTerrorUpdateHauntedGarden (int lp_team) {
    auto_libMDNC_gf_MMGardenTerrorUpdateHauntedGarden_lp_team = lp_team;

    if (auto_libMDNC_gf_MMGardenTerrorUpdateHauntedGarden_Trigger == null) {
        auto_libMDNC_gf_MMGardenTerrorUpdateHauntedGarden_Trigger = TriggerCreate("auto_libMDNC_gf_MMGardenTerrorUpdateHauntedGarden_TriggerFunc");
    }

    TriggerExecute(auto_libMDNC_gf_MMGardenTerrorUpdateHauntedGarden_Trigger, false, false);
}

bool auto_libMDNC_gf_MMGardenTerrorUpdateHauntedGarden_TriggerFunc (bool testConds, bool runActions) {
    int lp_team = auto_libMDNC_gf_MMGardenTerrorUpdateHauntedGarden_lp_team;

    // Variable Declarations
    int lv_itTeam;
    int lv_itPlayer;
    int lv_enemyTeam;

    // Automatic Variable Declarations
    playergroup auto6BC223F2_g;
    playergroup auto5A4CFB6E_g;
    const int autoB56FBA82_ae = 2;
    const int autoB56FBA82_ai = 1;

    // Variable Initialization

    // Implementation
    if ((UnitIsAlive(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_units) == true)) {
        if ((libMDNC_gv_mMGardenTerrorSeedsCollected[lp_team] >= libMDNC_gv_mMGardenTerrorSeedsRequested_C) && (libMDNC_gv_mMGardenTerrorBossSummoned[lp_team] == false) && (libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_growing == false) && (libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_readyToControl == false)) {
            libMDNC_gf_MMGardenTerrorGardenGrow(lp_team);
        }
        else {
            if ((libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_growing == false) && (libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_readyToControl == false)) {
                UnitBehaviorAddPlayer(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_units, "PlantHorrorDeactivated", UnitGetOwner(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_units), 1);
            }

        }
        if ((libMDNC_gv_mMGardenTerrorOpenFirstTime == true) && (libMDNC_gv_mMGardenTerrorNightFallen == false)) {
            UnitSetInfoTip(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_units, StringExternal("Param/Value/lib_MDNC_9FF96757"));
            UnitSetInfoTip(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_fertileSoil, StringExternal("Param/Value/lib_MDNC_8DCC42A8"));
        }
        else {
            if ((libMDNC_gv_mMGardenTerrorSeedsCollected[lp_team] < libMDNC_gv_mMGardenTerrorSeedsRequested_C) && (libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_growing == false) && (libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_readyToControl == false) && (libMDNC_gv_mMGardenTerrorBossSummoned[lp_team] == false)) {
                UnitSetInfoTip(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_units, StringExternal("Param/Value/lib_MDNC_E0DA88C3"));
                UnitSetInfoTip(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_fertileSoil, StringExternal("Param/Value/lib_MDNC_44800A61"));
                UnitSetState(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_units, c_unitStateTooltipable, true);
                UnitSetState(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_fertileSoil, c_unitStateHighlightable, true);
                UnitSetState(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_fertileSoil, c_unitStateTooltipable, true);
            }
            else {
                UnitSetState(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_units, c_unitStateTooltipable, false);
                UnitSetState(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_fertileSoil, c_unitStateHighlightable, false);
                UnitSetState(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_fertileSoil, c_unitStateTooltipable, false);
            }
        }
        auto5A4CFB6E_g = libGame_gf_PlayersOnTeamHeroes(lp_team, false);
        lv_itPlayer = -1;
        while (true) {
            	lv_itPlayer = PlayerGroupNextPlayer(auto5A4CFB6E_g, lv_itPlayer);
            	if (lv_itPlayer<0) { break; }
            	if ((libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_hintTextTag[lv_itPlayer] != c_textTagNone)) {
                if ((libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_growing == true)) {
                    TextTagSetText(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_hintTextTag[lv_itPlayer], StringToText(""));
                    TextTagSetPosition(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_hintTextTag[lv_itPlayer], PointWithOffset(UnitGetPosition(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_units), 0.0, 2.0), 1.0);
                }
                else {
                    if ((libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_readyToControl == true)) {
                        TextTagSetText(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_hintTextTag[lv_itPlayer], StringToText(""));
                    }
                    else {
                        TextTagSetText(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_hintTextTag[lv_itPlayer], StringExternal("Param/Value/lib_MDNC_40B72E99"));
                        TextTagSetPosition(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_hintTextTag[lv_itPlayer], PointWithOffset(UnitGetPosition(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_units), 0.0, 2.0), 1.0);
                    }
                }
            }

        }
    }
    else {
        auto6BC223F2_g = libGame_gf_PlayersOnTeamHeroes(lp_team, false);
        lv_itPlayer = -1;
        while (true) {
            	lv_itPlayer = PlayerGroupNextPlayer(auto6BC223F2_g, lv_itPlayer);
            	if (lv_itPlayer<0) { break; }
            	if ((libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_hintTextTag[lv_itPlayer] != c_textTagNone)) {
                TextTagDestroy(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_hintTextTag[lv_itPlayer]);
                libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_hintTextTag[lv_itPlayer] = c_textTagNone;
            }

        }
    }
    lv_itTeam = 1;
    for ( ; ( (autoB56FBA82_ai >= 0 && lv_itTeam <= autoB56FBA82_ae) || (autoB56FBA82_ai < 0 && lv_itTeam >= autoB56FBA82_ae) ) ; lv_itTeam += autoB56FBA82_ai ) {
        lv_enemyTeam = libGame_gf_EnemyTeam(lv_itTeam);
        if ((libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_ping[lv_itTeam] == c_invalidPingId)) {
            libNtve_gf_CreatePingFacingAngleWithType(libGame_gf_PlayersOnTeamHeroes(lv_itTeam, false), "PingObjective", libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_positions, ColorWithAlpha(100.00, 100.00, 0.00, 0.00), 0.0, 270.0, -1, -1);
            libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_ping[lv_itTeam] = PingLastCreated();
            PingSetScale(PingLastCreated(), 0.75);
        }

        if ((UnitIsAlive(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_units) == false)) {
            PingSetVisible(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_ping[lv_itTeam], false);
            if ((libNtve_gf_UnitIsVisibleToPlayer(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_pingUnit, UnitGetOwner(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_pingUnit)) == true)) {
                libNtve_gf_ShowHideUnit(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_pingUnit, false);
            }

            continue;
        }

        if ((libNtve_gf_UnitIsVisibleToPlayer(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_pingUnit, UnitGetOwner(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_pingUnit)) == false)) {
            libNtve_gf_ShowHideUnit(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_pingUnit, true);
        }

        if (((libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_readyToControl == true) || (libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_growing == true)) && (libMDNC_gv_mMGardenTerrorBossSummoned[lp_team] == false)) {
            PingSetVisible(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_ping[lv_itTeam], true);
        }
        else {
            PingSetVisible(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_ping[lv_itTeam], false);
        }
        if ((lv_itTeam == lp_team)) {
            PingSetColor(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_ping[lv_itTeam], Color(0.00, 100.00, 0.00));
        }
        else {
            PingSetColor(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_ping[lv_itTeam], Color(100.00, 0.00, 0.00));
        }
    }
    return true;
}

trigger auto_libMDNC_gf_MMGardenTerrorManageSummonBossPing_Trigger = null;
int auto_libMDNC_gf_MMGardenTerrorManageSummonBossPing_lp_team;

void libMDNC_gf_MMGardenTerrorManageSummonBossPing (int lp_team) {
    auto_libMDNC_gf_MMGardenTerrorManageSummonBossPing_lp_team = lp_team;

    if (auto_libMDNC_gf_MMGardenTerrorManageSummonBossPing_Trigger == null) {
        auto_libMDNC_gf_MMGardenTerrorManageSummonBossPing_Trigger = TriggerCreate("auto_libMDNC_gf_MMGardenTerrorManageSummonBossPing_TriggerFunc");
    }

    TriggerExecute(auto_libMDNC_gf_MMGardenTerrorManageSummonBossPing_Trigger, false, false);
}

bool auto_libMDNC_gf_MMGardenTerrorManageSummonBossPing_TriggerFunc (bool testConds, bool runActions) {
    int lp_team = auto_libMDNC_gf_MMGardenTerrorManageSummonBossPing_lp_team;

    // Variable Declarations
    int lv_timeIndex;

    // Automatic Variable Declarations
    int autoA992207E_val;

    // Variable Initialization

    // Implementation
    while (true) {
        if (((libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_readyToControl == false) || (libMDNC_gv_mMGardenTerrorBossSummoned[lp_team] == true) || (UnitIsAlive(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_units) == false))) {
            lv_timeIndex = 0;
            libMDNC_gf_MMGardenTerrorRemoveSummonBossPing(lp_team);
            libUIUI_gf_MapMechanicsGardenOfTerrorFlashSeedFrameStatusText(lp_team, false, 0);
            Wait(1.0, c_timeGame);
            continue;
        }

        if (((lv_timeIndex == 0) || (lv_timeIndex == 36) || (lv_timeIndex == 76))) {
            libMDNC_gf_MMGardenTerrorRemoveSummonBossPing(lp_team);
            autoA992207E_val = lv_timeIndex;
            if (autoA992207E_val == 0) {
                libCore_gf_CreateMinimapPingStorm(libGame_gf_PlayersOnTeamHeroes(lp_team, false), "StormAlert", libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_positions, Color(0.00, 100.00, 0.00), -1);
                libMDNC_gf_MMGardenTerrorTransmissionGolemWaitingQ(lp_team, 1);
                libUIUI_gf_MapMechanicsGardenOfTerrorFlashSeedFrameStatusText(lp_team, false, 0);
            }
            else if (autoA992207E_val == 36) {
                libCore_gf_CreateMinimapPingStorm(libGame_gf_PlayersOnTeamHeroes(lp_team, false), "StormAlert2", libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_positions, Color(0.00, 100.00, 0.00), -1);
                libMDNC_gf_MMGardenTerrorTransmissionGolemWaitingQ(lp_team, 2);
                libUIUI_gf_MapMechanicsGardenOfTerrorFlashSeedFrameStatusText(lp_team, true, 1);
            }
            else if (autoA992207E_val == 76) {
                libCore_gf_CreateMinimapPingStorm(libGame_gf_PlayersOnTeamHeroes(lp_team, false), "StormAlert2", libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_positions, Color(0.00, 100.00, 0.00), -1);
                libMDNC_gf_MMGardenTerrorTransmissionGolemWaitingQ(lp_team, 3);
                libUIUI_gf_MapMechanicsGardenOfTerrorFlashSeedFrameStatusText(lp_team, true, 2);
            }
            else {
            }
            libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_summonPing = PingLastCreated();
            PingSetScale(PingLastCreated(), 0.75);
            PingSetTooltip(PingLastCreated(), StringExternal("Param/Value/lib_MDNC_9C06954B"));
        }

        Wait(0.5, c_timeGame);
        lv_timeIndex += 1;
        if ((lv_timeIndex >= 120)) {
            lv_timeIndex = 0;
        }

    }
    return true;
}

void libMDNC_gf_MMGardenTerrorRemoveSummonBossPing (int lp_team) {
    // Automatic Variable Declarations
    // Implementation
    if ((libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_summonPing != c_invalidPingId)) {
        PingDestroy(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_summonPing);
        libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_summonPing = c_invalidPingId;
    }

}

void libMDNC_gf_MMGardenTerrorUpdateCampHibernating () {
    // Automatic Variable Declarations
    // Implementation
    if ((libMDNC_gv_mMGardenTerrorNightFallen == false) && (UnitIsAlive(libMDNC_gv_mMGardenTerrorSummonedBoss[libGame_gv_teamOrderIndex_C]) == false) && (UnitIsAlive(libMDNC_gv_mMGardenTerrorSummonedBoss[libGame_gv_teamChaosIndex_C]) == false)) {
        libMDNC_gf_MMGardenTerrorHibernateCamps(libMDNC_ge_MMGardenTerrorCampHibernateState_None);
    }
    else if (((UnitIsAlive(libMDNC_gv_mMGardenTerrorSummonedBoss[libGame_gv_teamOrderIndex_C]) == true) || (UnitIsAlive(libMDNC_gv_mMGardenTerrorSummonedBoss[libGame_gv_teamChaosIndex_C]) == true))) {
        libMDNC_gf_MMGardenTerrorHibernateCamps(libMDNC_ge_MMGardenTerrorCampHibernateState_Full);
    }
    else if (true) {
        libMDNC_gf_MMGardenTerrorHibernateCamps(libMDNC_ge_MMGardenTerrorCampHibernateState_None);
    }
}

void libMDNC_gf_MMGardenTerrorHibernateCamps (int lp_hibernate) {
    // Variable Declarations
    int lv_itCamp;

    // Automatic Variable Declarations
    int auto69BE22D0_val;

    // Variable Initialization

    // Implementation
    if ((libMDNC_gv_mMGardenTerrorCampsHibernateState == lp_hibernate)) {
        return ;
    }

    libMDNC_gv_mMGardenTerrorCampsHibernateState = lp_hibernate;
    auto69BE22D0_val = lp_hibernate;
    if (auto69BE22D0_val == libMDNC_ge_MMGardenTerrorCampHibernateState_Full) {
        libMapM_gf_JungleStartHibernateCamps();
    }
    else if (auto69BE22D0_val == libMDNC_ge_MMGardenTerrorCampHibernateState_None) {
        libMapM_gf_JungleStopHibernateCamps();
    }
    else if (auto69BE22D0_val == libMDNC_ge_MMGardenTerrorCampHibernateState_Partial) {
        libMapM_gf_JungleStartHibernateCamps();
    }
    else {
    }
}

trigger auto_libMDNC_gf_MMGardenTerrorSpawnNightMonsters_Trigger = null;

void libMDNC_gf_MMGardenTerrorSpawnNightMonsters () {
    if (auto_libMDNC_gf_MMGardenTerrorSpawnNightMonsters_Trigger == null) {
        auto_libMDNC_gf_MMGardenTerrorSpawnNightMonsters_Trigger = TriggerCreate("auto_libMDNC_gf_MMGardenTerrorSpawnNightMonsters_TriggerFunc");
    }

    TriggerExecute(auto_libMDNC_gf_MMGardenTerrorSpawnNightMonsters_Trigger, false, false);
}

bool auto_libMDNC_gf_MMGardenTerrorSpawnNightMonsters_TriggerFunc (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_itGroupIndex;

    // Automatic Variable Declarations
    int autoC31059BD_ae;
    const int autoC31059BD_ai = 1;
    int auto48FCF6FA_ae;
    const int auto48FCF6FA_ai = 1;

    // Variable Initialization

    // Implementation
    TriggerEnable(libMDNC_gt_MMGardenTerrorNightMonsterDies, true);
    autoC31059BD_ae = libMDNC_gv_mMGardenTerrorNightMinionGroupsCount;
    lv_itGroupIndex = 1;
    for ( ; ( (autoC31059BD_ai >= 0 && lv_itGroupIndex <= autoC31059BD_ae) || (autoC31059BD_ai < 0 && lv_itGroupIndex >= autoC31059BD_ae) ) ; lv_itGroupIndex += autoC31059BD_ai ) {
        libMDNC_gf_MMGardenTerrorSpawnNightMinionSingleGroup(lv_itGroupIndex);
        if ((ModI(lv_itGroupIndex, 2) == 0)) {
            Wait(0.0625, c_timeGame);
        }

    }
    auto48FCF6FA_ae = libMDNC_gv_mMGardenTerrorNightBossesCount;
    lv_itGroupIndex = 1;
    for ( ; ( (auto48FCF6FA_ai >= 0 && lv_itGroupIndex <= auto48FCF6FA_ae) || (auto48FCF6FA_ai < 0 && lv_itGroupIndex >= auto48FCF6FA_ae) ) ; lv_itGroupIndex += auto48FCF6FA_ai ) {
        if ((UnitIsAlive(libMDNC_gv_mMGardenTerrorNightBosses[lv_itGroupIndex].lv_unit) == false)) {
            libNtve_gf_CreateUnitsAtPoint2(1, "JunglePlantHorror", c_unitCreateIgnorePlacement, libCore_gv_cOMPUTER_Hostile, libMDNC_gv_mMGardenTerrorNightBosses[lv_itGroupIndex].lv_positions, null);
            libMDNC_gv_mMGardenTerrorNightBosses[lv_itGroupIndex].lv_unit = UnitLastCreated();
            UnitGroupAdd(libMDNC_gv_mMGardenTerrorNightMonsters, libMDNC_gv_mMGardenTerrorNightBosses[lv_itGroupIndex].lv_unit);
            AIAddMercenaryCamp(libMDNC_gv_mMGardenTerrorNightBosses[lv_itGroupIndex].lv_positions, libNtve_gf_ConvertUnitToUnitGroup(libMDNC_gv_mMGardenTerrorNightBosses[lv_itGroupIndex].lv_unit), "NightTerrorCamp");
            libMDNC_gv_mMGardenTerrorNightMonstersTotalCount += 1;
            libGame_gf_UpdateScalingForUnit(libMDNC_gv_mMGardenTerrorNightBosses[lv_itGroupIndex].lv_unit, libGame_gv_scalingTicks, 0);
            libAIAI_gf_StartDefenderAI(false, libNtve_gf_ConvertUnitToUnitGroup(libMDNC_gv_mMGardenTerrorNightBosses[lv_itGroupIndex].lv_unit), libMDNC_gv_mMGardenTerrorNightBosses[lv_itGroupIndex].lv_area, null, false);
            libNtve_gf_CreateUnitsAtPoint2(1, "JungleCampIconUnit", 0, libCore_gv_cOMPUTER_Hostile, UnitGetPosition(libMDNC_gv_mMGardenTerrorNightBosses[lv_itGroupIndex].lv_unit), null);
            libMDNC_gv_mMGardenTerrorNightBosses[lv_itGroupIndex].lv_unit2 = UnitLastCreated();
            libNtve_gf_SendActorMessageToUnit(UnitLastCreated(), "MinimapIcon Assets\\Textures\\storm_ui_minimapicon_gardengolem.dds");
            libNtve_gf_SendActorMessageToUnit(UnitLastCreated(), "MinimapIconScale 0.800000");
            libNtve_gf_SendActorMessageToUnit(UnitLastCreated(), "SetMinimapVisibility 1");
            libNtve_gf_SendActorMessageToUnit(UnitLastCreated(), "SetMinimapVisibilityAlways 1");
            libNtve_gf_SendActorMessageToUnit(UnitLastCreated(), "MinimapIconTintColor 255,180,90,218");
        }

    }
    return true;
}

trigger auto_libMDNC_gf_MMGardenTerrorSpawnNightMinionSingleGroup_Trigger = null;
int auto_libMDNC_gf_MMGardenTerrorSpawnNightMinionSingleGroup_lp_groupIndex;

void libMDNC_gf_MMGardenTerrorSpawnNightMinionSingleGroup (int lp_groupIndex) {
    auto_libMDNC_gf_MMGardenTerrorSpawnNightMinionSingleGroup_lp_groupIndex = lp_groupIndex;

    if (auto_libMDNC_gf_MMGardenTerrorSpawnNightMinionSingleGroup_Trigger == null) {
        auto_libMDNC_gf_MMGardenTerrorSpawnNightMinionSingleGroup_Trigger = TriggerCreate("auto_libMDNC_gf_MMGardenTerrorSpawnNightMinionSingleGroup_TriggerFunc");
    }

    TriggerExecute(auto_libMDNC_gf_MMGardenTerrorSpawnNightMinionSingleGroup_Trigger, false, false);
}

bool auto_libMDNC_gf_MMGardenTerrorSpawnNightMinionSingleGroup_TriggerFunc (bool testConds, bool runActions) {
    int lp_groupIndex = auto_libMDNC_gf_MMGardenTerrorSpawnNightMinionSingleGroup_lp_groupIndex;

    // Variable Declarations
    point lv_centerPoint;
    unit lv_itMinion;
    int lv_itMinionIndex;

    // Automatic Variable Declarations
    fixed autoA19B4EA6_at;
    int auto0F5F696F_ae;
    const int auto0F5F696F_ai = 1;

    // Variable Initialization

    // Implementation
    UnitGroupClear(libMDNC_gv_mMGardenTerrorNightMinionGroups[lp_groupIndex].lv_units);
    if ((libMDNC_gv_mMGardenTerrorNightMinionGroups[lp_groupIndex].lv_camp > 0)) {
        autoA19B4EA6_at = 0;
        while (!(((libMDNC_gv_mMGardenTerrorNightFallen == false) || (libMapM_gv_jungleCreepCamps[libMDNC_gv_mMGardenTerrorNightMinionGroups[lp_groupIndex].lv_camp].lv_aIState == libMapM_ge_JungleCampStates_Hibernating) || (libMapM_gv_jungleCreepCamps[libMDNC_gv_mMGardenTerrorNightMinionGroups[lp_groupIndex].lv_camp].lv_aIState == libMapM_ge_JungleCampStates_HibernatingReadyToRespawn))) && autoA19B4EA6_at <= libMDNC_gv_mMGardenTerrorNightDuration_C) {
            Wait(1.0, c_timeGame);
            autoA19B4EA6_at = autoA19B4EA6_at + 1.0;
        }
    }

    Wait(RandomFixed(0.0, 1.0), c_timeGame);
    if ((libMDNC_gv_mMGardenTerrorNightFallen == false)) {
        return true;
    }

    auto0F5F696F_ae = libMDNC_gv_mMGardenTerrorNightMinionGroups[lp_groupIndex].lv_minionCount;
    lv_itMinionIndex = 1;
    for ( ; ( (auto0F5F696F_ai >= 0 && lv_itMinionIndex <= auto0F5F696F_ae) || (auto0F5F696F_ai < 0 && lv_itMinionIndex >= auto0F5F696F_ae) ) ; lv_itMinionIndex += auto0F5F696F_ai ) {
        libNtve_gf_CreateUnitsAtPoint2(1, libMDNC_gv_mMGardenTerrorNightMinionGroups[lp_groupIndex].lv_minionType[lv_itMinionIndex], c_unitCreateIgnorePlacement, libCore_gv_cOMPUTER_Hostile, libMDNC_gv_mMGardenTerrorNightMinionGroups[lp_groupIndex].lv_positions[lv_itMinionIndex], null);
        lv_itMinion = UnitLastCreated();
        UnitGroupAdd(libMDNC_gv_mMGardenTerrorNightMonsters, lv_itMinion);
        UnitGroupAdd(libMDNC_gv_mMGardenTerrorNightMinionGroups[lp_groupIndex].lv_units, lv_itMinion);
        libMDNC_gv_mMGardenTerrorNightMonstersTotalCount += 1;
        libCore_gf_StoreIntegerForUnit(lv_itMinion, 1, lp_groupIndex);
        libGame_gf_UpdateScalingForUnit(lv_itMinion, libGame_gv_scalingTicks, 0);
        libNtve_gf_SendActorMessageToUnit(UnitLastCreated(), "SetMinimapVisibilityAlways");
        libNtve_gf_SendActorMessageToUnit(UnitLastCreated(), "SetMinimapVisibility");
    }
    lv_centerPoint = RegionGetCenter(libMDNC_gv_mMGardenTerrorNightMinionGroups[lp_groupIndex].lv_area);
    AIAddMercenaryCamp(lv_centerPoint, libMDNC_gv_mMGardenTerrorNightMinionGroups[lp_groupIndex].lv_units, "SeedlingCamp");
    libAIAI_gf_StartDefenderAI(false, libMDNC_gv_mMGardenTerrorNightMinionGroups[lp_groupIndex].lv_units, RegionCircle(RegionGetCenter(libMDNC_gv_mMGardenTerrorNightMinionGroups[lp_groupIndex].lv_area), 14.0), null, false);
    libMDNC_gv_mMGardenTerrorNightMinionGroupDefendIndex[lp_groupIndex] = libAIAI_gf_LastCreatedDefenderAI();
    libNtve_gf_CreateUnitsAtPoint2(1, "JungleCampIconUnit", 0, libCore_gv_cOMPUTER_Hostile, lv_centerPoint, null);
    libMDNC_gv_mMGardenTerrorNightMinionGroupIcons[lp_groupIndex] = UnitLastCreated();
    libNtve_gf_SendActorMessageToUnit(UnitLastCreated(), "MinimapIcon Assets\\Textures\\storm_ui_minimapicon_gardenhorror.dds");
    libNtve_gf_SendActorMessageToUnit(UnitLastCreated(), "SetMinimapVisibility 1");
    libNtve_gf_SendActorMessageToUnit(UnitLastCreated(), "SetMinimapVisibilityAlways 1");
    libNtve_gf_SendActorMessageToUnit(UnitLastCreated(), "MinimapIconScale 0.500000");
    libNtve_gf_SendActorMessageToUnit(UnitLastCreated(), "MinimapIconTintColor 255,180,90,218");
    return true;
}

trigger auto_libMDNC_gf_MMGardenTerrorNightMonstersDroppingSeeds_Trigger = null;

void libMDNC_gf_MMGardenTerrorNightMonstersDroppingSeeds () {
    if (auto_libMDNC_gf_MMGardenTerrorNightMonstersDroppingSeeds_Trigger == null) {
        auto_libMDNC_gf_MMGardenTerrorNightMonstersDroppingSeeds_Trigger = TriggerCreate("auto_libMDNC_gf_MMGardenTerrorNightMonstersDroppingSeeds_TriggerFunc");
    }

    TriggerExecute(auto_libMDNC_gf_MMGardenTerrorNightMonstersDroppingSeeds_Trigger, false, false);
}

bool auto_libMDNC_gf_MMGardenTerrorNightMonstersDroppingSeeds_TriggerFunc (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_i;
    unit lv_unit;

    // Automatic Variable Declarations
    int auto316F8BF9_ae;
    const int auto316F8BF9_ai = 1;
    int auto277C4FFA_ae;
    const int auto277C4FFA_ai = 1;
    unitgroup auto0C6EFB24_g;
    int auto0C6EFB24_u;

    // Variable Initialization

    // Implementation
    while ((libGame_gv_gameOver == false)) {
        auto316F8BF9_ae = libMDNC_gv_mMGardenTerrorNightBossesCount;
        lv_i = 1;
        for ( ; ( (auto316F8BF9_ai >= 0 && lv_i <= auto316F8BF9_ae) || (auto316F8BF9_ai < 0 && lv_i >= auto316F8BF9_ae) ) ; lv_i += auto316F8BF9_ai ) {
            if ((UnitIsAlive(libMDNC_gv_mMGardenTerrorNightBosses[lv_i].lv_unit) == true)) {
                libMDNC_gf_MMGardenTerrorNightBossDropsSeeds(lv_i);
            }

        }
        auto277C4FFA_ae = libMDNC_gv_mMGardenTerrorNightMinionGroupsCount;
        lv_i = 1;
        for ( ; ( (auto277C4FFA_ai >= 0 && lv_i <= auto277C4FFA_ae) || (auto277C4FFA_ai < 0 && lv_i >= auto277C4FFA_ae) ) ; lv_i += auto277C4FFA_ai ) {
            auto0C6EFB24_g = libMDNC_gv_mMGardenTerrorNightMinionGroups[lv_i].lv_units;
            auto0C6EFB24_u = UnitGroupCount(auto0C6EFB24_g, c_unitCountAll);
            for (;; auto0C6EFB24_u -= 1) {
                lv_unit = UnitGroupUnitFromEnd(auto0C6EFB24_g, auto0C6EFB24_u);
                if (lv_unit == null) { break; }
                if ((UnitIsAlive(lv_unit) == true)) {
                    libMDNC_gf_MMGardenTerrorNightMinionDropsSeeds(lv_unit);
                }

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

void libMDNC_gf_MMGardenTerrorNightBossDropsSeeds (int lp_bossIndex) {
    // Variable Declarations
    fixed lv_percent;
    int lv_droppedIndex;
    int lv_dropIndexMax;
    int lv_dropIndex;
    int lv_itDrop;
    int lv_itSeed;
    point lv_dropLoc;
    point lv_dropLocTemp;

    // Automatic Variable Declarations
    int autoEE0CAE54_ae;
    const int autoEE0CAE54_ai = 1;
    const int auto6F91A734_ae = libMDNC_gv_mMGardenTerrorDropSeedsBossPerHPDrop_C;
    const int auto6F91A734_ai = 1;
    int autoF17B48A5_ae;
    const int autoF17B48A5_ai = 1;
    const int auto8659008C_n = 20;
    int auto8659008C_i;

    // Variable Initialization
    lv_percent = UnitGetPropertyFixed(libMDNC_gv_mMGardenTerrorNightBosses[lp_bossIndex].lv_unit, c_unitPropLifePercent, c_unitPropCurrent);
    lv_droppedIndex = libCore_gf_IntegerStoredForUnit(libMDNC_gv_mMGardenTerrorNightBosses[lp_bossIndex].lv_unit, 2);
    lv_dropIndexMax = ((libMDNC_gv_mMGardenTerrorDropSeedsBossStartHPPercent_C+FixedToInt(libMDNC_gv_mMGardenTerrorDropSeedsBossPerHPPercent_C)-1)/FixedToInt(libMDNC_gv_mMGardenTerrorDropSeedsBossPerHPPercent_C));

    // Implementation
    if ((UnitIsAlive(libMDNC_gv_mMGardenTerrorNightBosses[lp_bossIndex].lv_unit) == true)) {
        lv_dropIndex = ((libMDNC_gv_mMGardenTerrorDropSeedsBossStartHPPercent_C+FixedToInt(libMDNC_gv_mMGardenTerrorDropSeedsBossPerHPPercent_C)-1-FixedToInt(lv_percent))/FixedToInt(libMDNC_gv_mMGardenTerrorDropSeedsBossPerHPPercent_C));
        lv_dropIndex = MinI(lv_dropIndex, lv_dropIndexMax);
    }
    else {
        lv_dropIndex = lv_dropIndexMax;
    }
    if ((lv_dropIndex > lv_droppedIndex)) {
        libCore_gf_StoreIntegerForUnit(libMDNC_gv_mMGardenTerrorNightBosses[lp_bossIndex].lv_unit, 2, lv_dropIndex);
        autoEE0CAE54_ae = lv_dropIndex;
        lv_itDrop = (lv_droppedIndex + 1);
        for ( ; ( (autoEE0CAE54_ai >= 0 && lv_itDrop <= autoEE0CAE54_ae) || (autoEE0CAE54_ai < 0 && lv_itDrop >= autoEE0CAE54_ae) ) ; lv_itDrop += autoEE0CAE54_ai ) {
            lv_itSeed = 1;
            for ( ; ( (auto6F91A734_ai >= 0 && lv_itSeed <= auto6F91A734_ae) || (auto6F91A734_ai < 0 && lv_itSeed >= auto6F91A734_ae) ) ; lv_itSeed += auto6F91A734_ai ) {
                libMDNC_gf_MMGardenTerrorDropSeeds(UnitGetPosition(libMDNC_gv_mMGardenTerrorNightBosses[lp_bossIndex].lv_unit), 1, true);
            }
        }
    }

    lv_droppedIndex = libCore_gf_IntegerStoredForUnit(libMDNC_gv_mMGardenTerrorNightBosses[lp_bossIndex].lv_unit, 3);
    lv_dropIndexMax = 2;
    if ((UnitIsAlive(libMDNC_gv_mMGardenTerrorNightBosses[lp_bossIndex].lv_unit) == true)) {
        if ((lv_percent <= 30.0)) {
            lv_dropIndex = 2;
        }
        else if ((lv_percent <= 70.0)) {
            lv_dropIndex = 1;
        }
        else if (true) {
            lv_dropIndex = 0;
        }
    }
    else {
        lv_dropIndex = lv_dropIndexMax;
    }
    if ((lv_dropIndex > lv_droppedIndex)) {
        libCore_gf_StoreIntegerForUnit(libMDNC_gv_mMGardenTerrorNightBosses[lp_bossIndex].lv_unit, 3, lv_dropIndex);
        autoF17B48A5_ae = lv_dropIndex;
        lv_itDrop = (lv_droppedIndex + 1);
        for ( ; ( (autoF17B48A5_ai >= 0 && lv_itDrop <= autoF17B48A5_ae) || (autoF17B48A5_ai < 0 && lv_itDrop >= autoF17B48A5_ae) ) ; lv_itDrop += autoF17B48A5_ai ) {
            lv_dropLoc = null;
            for (auto8659008C_i = 1; auto8659008C_i <= auto8659008C_n; auto8659008C_i += 1) {
                lv_dropLocTemp = PointWithOffsetPolar(UnitGetPosition(libMDNC_gv_mMGardenTerrorNightBosses[lp_bossIndex].lv_unit), RandomFixed(5.0, 6.5), libNtve_gf_RandomAngle());
                if ((RegionContainsPoint(libMDNC_gv_mMGardenTerrorNightBosses[lp_bossIndex].lv_area, lv_dropLocTemp) == true)) {
                    lv_dropLoc = lv_dropLocTemp;
                    break;
                }

            }
            if ((lv_dropLoc == null)) {
                lv_dropLoc = PointWithOffsetPolar(UnitGetPosition(libMDNC_gv_mMGardenTerrorNightBosses[lp_bossIndex].lv_unit), RandomFixed(2.0, 3.0), libNtve_gf_RandomAngle());
            }

            UnitCreateEffectPoint(libMDNC_gv_mMGardenTerrorNightBosses[lp_bossIndex].lv_unit, "RegenGlobeNeutralCreatePrecursorUnit", lv_dropLoc);
        }
    }

}

int libMDNC_gf_MMGardenTerrorNightPerBossTotalSeeds () {
    // Variable Declarations
    int lv_dropIndexMax;
    int lv_itDrop;
    int lv_count;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    lv_dropIndexMax = ((libMDNC_gv_mMGardenTerrorDropSeedsBossStartHPPercent_C+FixedToInt(libMDNC_gv_mMGardenTerrorDropSeedsBossPerHPPercent_C)-1)/FixedToInt(libMDNC_gv_mMGardenTerrorDropSeedsBossPerHPPercent_C));
    lv_count = (lv_dropIndexMax * libMDNC_gv_mMGardenTerrorDropSeedsBossPerHPDrop_C);
    lv_count += libMDNC_gv_mMGardenTerrorDropSeedsBossFinalDrop_C;
    return lv_count;
}

int libMDNC_gf_MMGardenTerrorNightMinionGroupIndex (unit lp_minion) {
    // Automatic Variable Declarations
    // Implementation
    return libCore_gf_IntegerStoredForUnit(lp_minion, 1);
}

void libMDNC_gf_MMGardenTerrorNightMinionDropsSeeds (unit lp_minion) {
    // Variable Declarations
    int lv_droppedIndex;
    int lv_dropIndex;
    int lv_dropIndexMax;
    int lv_itDrop;
    int lv_itSeed;
    fixed lv_percent;

    // Automatic Variable Declarations
    int auto7E9A674F_ae;
    const int auto7E9A674F_ai = 1;
    const int auto8411C4CD_ae = libMDNC_gv_mMGardenTerrorDropSeedsMinionPerHPDrop_C;
    const int auto8411C4CD_ai = 1;

    // Variable Initialization

    // Implementation
    lv_droppedIndex = libCore_gf_IntegerStoredForUnit(lp_minion, 2);
    lv_dropIndexMax = ((libMDNC_gv_mMGardenTerrorDropSeedsMinionStartHPPercent_C+FixedToInt(libMDNC_gv_mMGardenTerrorDropSeedsMinionPerHPPercent_C)-1)/FixedToInt(libMDNC_gv_mMGardenTerrorDropSeedsMinionPerHPPercent_C));
    if ((UnitIsAlive(lp_minion) == true)) {
        lv_percent = UnitGetPropertyFixed(lp_minion, c_unitPropLifePercent, c_unitPropCurrent);
        lv_dropIndex = ((libMDNC_gv_mMGardenTerrorDropSeedsMinionStartHPPercent_C+FixedToInt(libMDNC_gv_mMGardenTerrorDropSeedsMinionPerHPPercent_C)-1-FixedToInt(lv_percent))/FixedToInt(libMDNC_gv_mMGardenTerrorDropSeedsMinionPerHPPercent_C));
        lv_dropIndex = MinI(lv_dropIndex, lv_dropIndexMax);
    }
    else {
        lv_dropIndex = lv_dropIndexMax;
    }
    if ((lv_dropIndex <= lv_droppedIndex)) {
        return ;
    }

    libCore_gf_StoreIntegerForUnit(lp_minion, 2, lv_dropIndex);
    auto7E9A674F_ae = lv_dropIndex;
    lv_itDrop = (lv_droppedIndex + 1);
    for ( ; ( (auto7E9A674F_ai >= 0 && lv_itDrop <= auto7E9A674F_ae) || (auto7E9A674F_ai < 0 && lv_itDrop >= auto7E9A674F_ae) ) ; lv_itDrop += auto7E9A674F_ai ) {
        lv_itSeed = 1;
        for ( ; ( (auto8411C4CD_ai >= 0 && lv_itSeed <= auto8411C4CD_ae) || (auto8411C4CD_ai < 0 && lv_itSeed >= auto8411C4CD_ae) ) ; lv_itSeed += auto8411C4CD_ai ) {
            libMDNC_gf_MMGardenTerrorDropSeeds(UnitGetPosition(lp_minion), 1, false);
        }
    }
}

int libMDNC_gf_MMGardenTerrorNightPerMinionTotalSeeds () {
    // Variable Declarations
    int lv_dropIndexMax;
    int lv_itDrop;
    int lv_count;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    lv_dropIndexMax = ((libMDNC_gv_mMGardenTerrorDropSeedsMinionStartHPPercent_C+FixedToInt(libMDNC_gv_mMGardenTerrorDropSeedsMinionPerHPPercent_C)-1)/FixedToInt(libMDNC_gv_mMGardenTerrorDropSeedsMinionPerHPPercent_C));
    lv_count = (lv_dropIndexMax * libMDNC_gv_mMGardenTerrorDropSeedsMinionPerHPDrop_C);
    lv_count += libMDNC_gv_mMGardenTerrorDropSeedsMinionFinalDrop_C;
    return lv_count;
}

int libMDNC_gf_MMGardenTerrorNightSeedsTotal () {
    // Variable Declarations
    int lv_itGroup;
    int lv_count;

    // Automatic Variable Declarations
    int auto478FAAC4_ae;
    const int auto478FAAC4_ai = 1;
    int autoC3DC8E53_ae;
    const int autoC3DC8E53_ai = 1;

    // Variable Initialization

    // Implementation
    auto478FAAC4_ae = libMDNC_gv_mMGardenTerrorNightMinionGroupsCount;
    lv_itGroup = 1;
    for ( ; ( (auto478FAAC4_ai >= 0 && lv_itGroup <= auto478FAAC4_ae) || (auto478FAAC4_ai < 0 && lv_itGroup >= auto478FAAC4_ae) ) ; lv_itGroup += auto478FAAC4_ai ) {
        lv_count += (libMDNC_gf_MMGardenTerrorNightPerMinionTotalSeeds() * libMDNC_gv_mMGardenTerrorNightMinionGroups[lv_itGroup].lv_minionCount);
    }
    autoC3DC8E53_ae = libMDNC_gv_mMGardenTerrorNightBossesCount;
    lv_itGroup = 1;
    for ( ; ( (autoC3DC8E53_ai >= 0 && lv_itGroup <= autoC3DC8E53_ae) || (autoC3DC8E53_ai < 0 && lv_itGroup >= autoC3DC8E53_ae) ) ; lv_itGroup += autoC3DC8E53_ai ) {
        lv_count += libMDNC_gf_MMGardenTerrorNightPerBossTotalSeeds();
    }
    return lv_count;
}

void libMDNC_gf_MMGardenTerrorDropSeeds (point lp_location, int lp_count, bool lp_forBoss) {
    // Automatic Variable Declarations
    int autoA4BF4907_n;
    int autoA4BF4907_i;

    // Implementation
    if ((lp_count <= 0)) {
        return ;
    }

    if ((lp_forBoss == true)) {
        if ((lp_count > 1)) {
            CatalogFieldValueSet(c_gameCatalogEffect, "PlantHorrorSpawnSeeds", "PeriodCount", libCore_gv_cOMPUTER_Neutral, IntToString(lp_count));
            PlayerCreateEffectPoint(libCore_gv_cOMPUTER_Neutral, "PlantHorrorSpawnSeeds", lp_location);
        }
        else {
            PlayerCreateEffectPoint(libCore_gv_cOMPUTER_Neutral, "PlantHorrorSpawnSeedsSingleFar", lp_location);
        }
    }
    else {
        autoA4BF4907_n = lp_count;
        for (autoA4BF4907_i = 1; autoA4BF4907_i <= autoA4BF4907_n; autoA4BF4907_i += 1) {
            PlayerCreateEffectPoint(libCore_gv_cOMPUTER_Neutral, "PlantHorrorSpawnSeedsSingleClose", lp_location);
        }
    }
}

int libMDNC_gf_MMGardenTerrorNightSeedsLeft () {
    // Variable Declarations
    int lv_count;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    lv_count = libMDNC_gf_MMGardenTerrorNightSeedsTotal();
    return (libMDNC_gf_MMGardenTerrorNightSeedsTotal()-libMDNC_gv_mMGardenTerrorSeedsCollectedTonight[1]-libMDNC_gv_mMGardenTerrorSeedsCollectedTonight[2]);
}

unit libMDNC_gf_MMGardenTerrorPlayerHeroUnit (int lp_player) {
    // Automatic Variable Declarations
    // Implementation
    if ((libGame_gv_players[lp_player].lv_activeVehicle != null) && (UnitIsAlive(libGame_gv_players[lp_player].lv_activeVehicle) == true)) {
        return libGame_gv_players[lp_player].lv_activeVehicle;
    }

    return libGame_gv_players[lp_player].lv_heroUnit;
}

fixed libMDNC_gf_MMGardenTerrorSummonedGolemDuration () {
    // Automatic Variable Declarations
    // Implementation
    return MinF((80.0+2*libGame_gv_scalingTicks), 120.0);
}

trigger auto_libMDNC_gf_MMGardenTerrorGardenGrow_Trigger = null;
int auto_libMDNC_gf_MMGardenTerrorGardenGrow_lp_team;

void libMDNC_gf_MMGardenTerrorGardenGrow (int lp_team) {
    auto_libMDNC_gf_MMGardenTerrorGardenGrow_lp_team = lp_team;

    if (auto_libMDNC_gf_MMGardenTerrorGardenGrow_Trigger == null) {
        auto_libMDNC_gf_MMGardenTerrorGardenGrow_Trigger = TriggerCreate("auto_libMDNC_gf_MMGardenTerrorGardenGrow_TriggerFunc");
    }

    TriggerExecute(auto_libMDNC_gf_MMGardenTerrorGardenGrow_Trigger, false, false);
}

bool auto_libMDNC_gf_MMGardenTerrorGardenGrow_TriggerFunc (bool testConds, bool runActions) {
    int lp_team = auto_libMDNC_gf_MMGardenTerrorGardenGrow_lp_team;

    // Variable Declarations
    fixed lv_duration;
    int lv_growTextTag;
    timer lv_growTimer;
    fixed lv_remainingDuration;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_growTextTag = c_textTagNone;
    lv_growTimer = TimerCreate();

    // Implementation
    if ((libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_growing == true)) {
        return true;
    }

    libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_growing = true;
    libNtve_gf_SendActorMessageToUnit(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_units, "Signal Channel");
    ActorSend(libNtve_gf_MainActorofUnit(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_fertileSoil), "AnimGroupApply Ready Stand,Ready,Start {} 0 1.000000 AsTimeScale");
    libNtve_gf_SendActorMessageToUnit(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_fertileSoil, "Signal Ready");
    Wait(0.5, c_timeGame);
    libMDNC_gv_mMGardenTerrorSeedsCollected[lp_team] = (libMDNC_gv_mMGardenTerrorSeedsCollected[lp_team] - libMDNC_gv_mMGardenTerrorSeedsRequested_C);
    libMDNC_gf_MMGardenTerrorTransmissionGolemStartGrowingQ(lp_team);
    libMDNC_gf_MMGardenTerrorUIGardenTerrorGrow(lp_team);
    TimerStart(lv_growTimer, libMDNC_gv_mMGardenTerrorGardenGrowDuration_C, false, c_timeGame);
    TextTagCreate(StringToText(""), 32, PointWithOffset(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_positions, 0.0, 2.0), 0.5, true, false, libGame_gf_PlayersOnTeamHeroes(lp_team, false));
    lv_growTextTag = TextTagLastCreated();
    while (true) {
        if ((TimerGetRemaining(lv_growTimer) == 0.0)) {
            TextTagDestroy(lv_growTextTag);
            break;
        }

        TextExpressionSetToken("Param/Expression/lib_MDNC_F1F2E20C", "A", TextTimeFormat(StringToText("<min2/>:<sec2/>"), FixedToInt(TimerGetRemaining(lv_growTimer))));
        TextTagSetText(lv_growTextTag, TextExpressionAssemble("Param/Expression/lib_MDNC_F1F2E20C"));
        Wait(0.25, c_timeGame);
    }
    libMDNC_gf_MMGardenTerrorUpdateHauntedGarden(lp_team);
    UnitStatusBarOverride(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_units, -1);
    libNtve_gf_SendActorMessageToUnit(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_units, "Signal ChannelCancel");
    UnitBehaviorRemovePlayer(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_units, "PlantHorrorDeactivated", UnitGetOwner(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_units), 1);
    UnitSetPosition(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_units, PointWithOffsetPolar(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_positions, 2.0, libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_facing), false);
    libNtve_gf_SendActorMessageToUnit(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_units, "Signal Finished");
    UnitBehaviorAddPlayer(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_units, "PlantHorrorTimedLife", libCore_gv_cOMPUTER_Neutral, 1);
    lv_duration = libMDNC_gv_mMGardenTerrorGardenLifeDuration_C;
    UnitBehaviorSetDuration(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_units, "PlantHorrorTimedLife", lv_duration);
    UnitBehaviorSetDurationRemaining(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_units, "PlantHorrorTimedLife", lv_duration);
    libMDNC_gf_MMGardenTerrorUpdateHauntedGarden(lp_team);
    Wait(2.0, c_timeGame);
    libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_growing = false;
    libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_readyToControl = true;
    TextTagCreate(StringToText(""), 32, PointWithOffset(UnitGetPosition(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_units), 1.0, 2.0), 0.5, true, false, libGame_gf_PlayersOnTeamHeroes(lp_team, false));
    libMDNC_gf_MMGardenTerrorAddInteractGoalAfterDelay(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_units);
    lv_growTextTag = TextTagLastCreated();
    while (true) {
        if (((UnitIsAlive(libMDNC_gv_mMGardenTerrorSummonedBoss[lp_team]) == true) || (UnitIsAlive(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_units) == false))) {
            TextTagDestroy(lv_growTextTag);
            break;
        }

        lv_remainingDuration = UnitBehaviorDuration(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_units, "PlantHorrorTimedLife");
        TextExpressionSetToken("Param/Expression/lib_MDNC_2FA3D8E3", "A", TextTimeFormat(StringToText("<min2/>:<sec2/>"), FixedToInt(lv_remainingDuration)));
        TextTagSetText(lv_growTextTag, TextExpressionAssemble("Param/Expression/lib_MDNC_2FA3D8E3"));
        libUIUI_gf_MapMechanicsGardenOfTerrorSetGolemGrowTimeForTeam(lp_team, FixedToInt(lv_remainingDuration));
        Wait(0.25, c_timeGame);
    }
    libUIUI_gf_MapMechanicsGardenOfTerrorSetGolemGrowTimeForTeam(lp_team, 0);
    libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_readyToControl = false;
    libMDNC_gf_MMGardenTerrorUpdateHauntedGarden(lp_team);
    if ((UnitIsAlive(libMDNC_gv_mMGardenTerrorSummonedBoss[lp_team]) == false)) {
        libMDNC_gf_MMGardenTerrorGardenCooldown(lp_team);
        libMDNC_gf_MMGardenTerrorTransmissionGolemWastedQ(lp_team);
    }

    return true;
}

void libMDNC_gf_MMGardenTerrorAddInteractGoalAfterDelay (unit lp_vehicleUnit) {
    // Automatic Variable Declarations
    // Implementation
    if ((UnitIsAlive(lp_vehicleUnit) == true)) {
        AddUnitOfInterest(lp_vehicleUnit, 1.5, libMDNC_gv_mMGardenTerrorGardenGrowDuration_C, "EnterGardenTerror", libAIAI_gf_ConvertIntegertoGoalTeam(libGame_gf_TeamNumberOfPlayer(UnitGetOwner(lp_vehicleUnit))), 0);
    }

}

trigger auto_libMDNC_gf_MMGardenTerrorGardenCooldown_Trigger = null;
int auto_libMDNC_gf_MMGardenTerrorGardenCooldown_lp_team;

void libMDNC_gf_MMGardenTerrorGardenCooldown (int lp_team) {
    auto_libMDNC_gf_MMGardenTerrorGardenCooldown_lp_team = lp_team;

    if (auto_libMDNC_gf_MMGardenTerrorGardenCooldown_Trigger == null) {
        auto_libMDNC_gf_MMGardenTerrorGardenCooldown_Trigger = TriggerCreate("auto_libMDNC_gf_MMGardenTerrorGardenCooldown_TriggerFunc");
    }

    TriggerExecute(auto_libMDNC_gf_MMGardenTerrorGardenCooldown_Trigger, false, false);
}

bool auto_libMDNC_gf_MMGardenTerrorGardenCooldown_TriggerFunc (bool testConds, bool runActions) {
    int lp_team = auto_libMDNC_gf_MMGardenTerrorGardenCooldown_lp_team;

    // Variable Declarations
    int lv_cooldownTextTag;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_cooldownTextTag = c_textTagNone;

    // Implementation
    if ((TimerGetRemaining(libMDNC_gv_mMGardenTerrorGolemCooldownTimer[lp_team]) > 0.0)) {
        return true;
    }

    TimerStart(libMDNC_gv_mMGardenTerrorGolemCooldownTimer[lp_team], libMDNC_gv_mMGardenTerrorGardenCooldown_C, false, c_timeGame);
    TextTagCreate(StringToText(""), 32, libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_positions, 0.5, true, false, libGame_gf_PlayersOnTeamHeroes(lp_team, false));
    lv_cooldownTextTag = TextTagLastCreated();
    while (true) {
        if ((TimerGetRemaining(libMDNC_gv_mMGardenTerrorGolemCooldownTimer[lp_team]) == 0.0)) {
            TextTagDestroy(lv_cooldownTextTag);
            libNtve_gf_SendActorMessageToUnit(libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_fertileSoil, "StatusSet ReadyPing 0");
            break;
        }

        TextExpressionSetToken("Param/Expression/lib_MDNC_564704B7", "A", TextTimeFormat(StringToText("<min2/>:<sec2/>"), FixedToInt(TimerGetRemaining(libMDNC_gv_mMGardenTerrorGolemCooldownTimer[lp_team]))));
        TextTagSetText(lv_cooldownTextTag, TextExpressionAssemble("Param/Expression/lib_MDNC_564704B7"));
        Wait(0.25, c_timeGame);
    }
    libMDNC_gf_MMGardenTerrorCreateHauntedGarden(lp_team, true);
    return true;
}

void libMDNC_gf_MMGardenTerrorUIUpdateText () {
    // Variable Declarations
    int lv_itTeam;
    bool lv_golemSummonPossible;

    // Automatic Variable Declarations
    const int autoD770408A_ae = libCore_gv_bALMaxTeams;
    const int autoD770408A_ai = 1;

    // Variable Initialization

    // Implementation
    lv_itTeam = 1;
    for ( ; ( (autoD770408A_ai >= 0 && lv_itTeam <= autoD770408A_ae) || (autoD770408A_ai < 0 && lv_itTeam >= autoD770408A_ae) ) ; lv_itTeam += autoD770408A_ai ) {
        if (((libMDNC_gv_mMGardenTerrorSeedsCollected[lv_itTeam] + libMDNC_gf_MMGardenTerrorNightSeedsLeft()) < libMDNC_gv_mMGardenTerrorSeedsRequested_C) && (libMDNC_gv_mMGardenTerrorNightFallen == true)) {
            lv_golemSummonPossible = false;
        }
        else {
            lv_golemSummonPossible = true;
        }
        libUIUI_gf_MapMechanicsGardenOfTerrorSetGolemSummonPossibleForTeam(lv_itTeam, lv_golemSummonPossible);
        libUIUI_gf_MapMechanicsGardenOfTerrorSetSeedCountForTeam(IntToText(libMDNC_gv_mMGardenTerrorSeedsCollected[lv_itTeam]), lv_itTeam, lv_golemSummonPossible);
    }
}

void libMDNC_gf_MMGardenTerrorUIUpdateGolemPanel () {
    // Variable Declarations
    int lv_itTeam;
    bool lv_showOrHidePanel;

    // Automatic Variable Declarations
    const int auto417D9182_ae = libCore_gv_bALMaxTeams;
    const int auto417D9182_ai = 1;

    // Variable Initialization
    lv_showOrHidePanel = true;

    // Implementation
    lv_showOrHidePanel = false;
    lv_itTeam = 1;
    for ( ; ( (auto417D9182_ai >= 0 && lv_itTeam <= auto417D9182_ae) || (auto417D9182_ai < 0 && lv_itTeam >= auto417D9182_ae) ) ; lv_itTeam += auto417D9182_ai ) {
        if ((UnitIsAlive(libMDNC_gv_mMGardenTerrorSummonedBoss[lv_itTeam]) == true)) {
            libUIUI_gf_MapMechanicsGardenOfTerrorSetGolemStatusTextForTeam(lv_itTeam, libUIUI_ge_MapMechanicsGardenOfTerrorGolemStatusText_Active);
            libUIUI_gf_MapMechanicsGardenOfTerrorSetSeedFrameStatusTextForTeam(lv_itTeam, libUIUI_ge_MapMechanicsGardenOfTerrorGolemStatusText_Active);
            lv_showOrHidePanel = true;
        }
        else {
            if ((libMDNC_gv_mMGardenTerrorGarden[lv_itTeam].lv_growing == true)) {
                libUIUI_gf_MapMechanicsGardenOfTerrorSetGolemStatusTextForTeam(lv_itTeam, libUIUI_ge_MapMechanicsGardenOfTerrorGolemStatusText_Growing);
                libUIUI_gf_MapMechanicsGardenOfTerrorSetSeedFrameStatusTextForTeam(lv_itTeam, libUIUI_ge_MapMechanicsGardenOfTerrorGolemStatusText_Growing);
            }
            else {
                if ((libMDNC_gv_mMGardenTerrorGarden[lv_itTeam].lv_readyToControl == true)) {
                    libUIUI_gf_MapMechanicsGardenOfTerrorSetGolemStatusTextForTeam(lv_itTeam, libUIUI_ge_MapMechanicsGardenOfTerrorGolemStatusText_ReadyToSummon);
                    libUIUI_gf_MapMechanicsGardenOfTerrorSetSeedFrameStatusTextForTeam(lv_itTeam, libUIUI_ge_MapMechanicsGardenOfTerrorGolemStatusText_ReadyToSummon);
                }
                else if ((libMDNC_gv_mMGardenTerrorSeedsCollected[lv_itTeam] >= libMDNC_gv_mMGardenTerrorSeedsRequested_C) && (TimerGetRemaining(libMDNC_gv_mMGardenTerrorGolemCooldownTimer[lv_itTeam]) > 0.0)) {
                    libUIUI_gf_MapMechanicsGardenOfTerrorSetGolemStatusTextForTeam(lv_itTeam, libUIUI_ge_MapMechanicsGardenOfTerrorGolemStatusText_WaitToSummon);
                    libUIUI_gf_MapMechanicsGardenOfTerrorSetSeedFrameStatusTextForTeam(lv_itTeam, libUIUI_ge_MapMechanicsGardenOfTerrorGolemStatusText_WaitToSummon);
                    lv_showOrHidePanel = true;
                }
                else if (true) {
                    libUIUI_gf_MapMechanicsGardenOfTerrorSetGolemStatusTextForTeam(lv_itTeam, libUIUI_ge_MapMechanicsGardenOfTerrorGolemStatusText_Null);
                    libUIUI_gf_MapMechanicsGardenOfTerrorSetSeedFrameStatusTextForTeam(lv_itTeam, libUIUI_ge_MapMechanicsGardenOfTerrorGolemStatusText_Null);
                }
            }
        }
    }
    libUIUI_gf_MapMechanicsGardenOfTerrorShowHideGolemFrame(lv_showOrHidePanel);
}

trigger auto_libMDNC_gf_MMGardenTerrorUIGardenTerrorGrow_Trigger = null;
int auto_libMDNC_gf_MMGardenTerrorUIGardenTerrorGrow_lp_team;

void libMDNC_gf_MMGardenTerrorUIGardenTerrorGrow (int lp_team) {
    auto_libMDNC_gf_MMGardenTerrorUIGardenTerrorGrow_lp_team = lp_team;

    if (auto_libMDNC_gf_MMGardenTerrorUIGardenTerrorGrow_Trigger == null) {
        auto_libMDNC_gf_MMGardenTerrorUIGardenTerrorGrow_Trigger = TriggerCreate("auto_libMDNC_gf_MMGardenTerrorUIGardenTerrorGrow_TriggerFunc");
    }

    TriggerExecute(auto_libMDNC_gf_MMGardenTerrorUIGardenTerrorGrow_Trigger, false, false);
}

bool auto_libMDNC_gf_MMGardenTerrorUIGardenTerrorGrow_TriggerFunc (bool testConds, bool runActions) {
    int lp_team = auto_libMDNC_gf_MMGardenTerrorUIGardenTerrorGrow_lp_team;

    // Variable Declarations
    fixed lv_current;
    timer lv_growTimer;
    unit lv_tempGolem;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_growTimer = TimerCreate();

    // Implementation
    TimerStart(lv_growTimer, libMDNC_gv_mMGardenTerrorGardenGrowDuration_C, false, c_timeGame);
    libNtve_gf_CreateUnitsWithDefaultFacing(1, "JunglePlantHorror", c_unitCreateIgnorePlacement, libGame_gf_ComputerPlayerInTeam(lp_team), libMDNC_gv_mMGardenTerrorGarden[lp_team].lv_positions, null);
    lv_tempGolem = UnitLastCreated();
    libNtve_gf_ShowHideUnit(UnitLastCreated(), false);
    libNtve_gf_MakeUnitInvulnerable(UnitLastCreated(), true);
    libNtve_gf_PauseUnit(UnitLastCreated(), true);
    UnitSetState(UnitLastCreated(), c_unitStateTargetable, false);
    UnitSetState(UnitLastCreated(), c_unitStateRadarable, false);
    UnitSetState(UnitLastCreated(), c_unitStateStatusBar, false);
    UnitSetState(UnitLastCreated(), c_unitStateSelectable, false);
    UnitSetState(UnitLastCreated(), c_unitStateHighlightable, false);
    UnitSetState(UnitLastCreated(), c_unitStateDetectable, false);
    UnitSetState(UnitLastCreated(), c_unitStateCursorable, false);
    UnitSetPropertyFixed(UnitLastCreated(), c_unitPropLifeMax, 2000.0);
    UnitSetPropertyFixed(lv_tempGolem, c_unitPropLifePercent, 0.1);
    while (true) {
        libUIUI_gf_MapMechanicsGardenOfTerrorSetGolemGrowTimeForTeam(lp_team, FixedToInt(TimerGetRemaining(lv_growTimer)));
        lv_current = (TimerGetElapsed(lv_growTimer)*100/TimerGetDuration(lv_growTimer));
        if ((lv_current > 0.1)) {
            UnitSetPropertyFixed(lv_tempGolem, c_unitPropLifePercent, lv_current);
        }

        Wait(0.125, c_timeGame);
        if ((TimerGetRemaining(lv_growTimer) == 0.0)) {
            break;
        }

    }
    UnitRemove(lv_tempGolem);
    return true;
}

void libMDNC_gf_MMGardenTerrorGolemSummonedArt () {
    // Automatic Variable Declarations
    // Implementation
    ActorSend(libMapM_gv_mapMechanicControllerActor, "Signal MM1On");
}

void libMDNC_gf_MMGardenTerrorGolemKilledExpiredArt () {
    // Automatic Variable Declarations
    // Implementation
    ActorSend(libMapM_gv_mapMechanicControllerActor, "Signal MM1Off");
    ActorSend(libMapM_gv_mapMechanicControllerActor, "Signal MM2On");
}

trigger auto_libMDNC_gf_MMDragonballsTransmissionDragonExpireQ2_Trigger = null;

void libMDNC_gf_MMDragonballsTransmissionDragonExpireQ2 () {
    if (auto_libMDNC_gf_MMDragonballsTransmissionDragonExpireQ2_Trigger == null) {
        auto_libMDNC_gf_MMDragonballsTransmissionDragonExpireQ2_Trigger = TriggerCreate("auto_libMDNC_gf_MMDragonballsTransmissionDragonExpireQ2_TriggerFunc");
    }

    TriggerExecute(auto_libMDNC_gf_MMDragonballsTransmissionDragonExpireQ2_Trigger, false, false);
}

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

    TriggerQueueEnter();
    UserDataResetType("MapVOEvent");
    UserDataSetInt("MapVOEvent", "Gardens - Night Soon First", "Value", 1, 1);
    ConversationDataRun("GardensofTerror", PlayerGroupAll(), c_conversationSkipNone, false);
    libCore_gf_WaitForConversationToFinish();
    TriggerQueueExit();
    return true;
}

trigger auto_libMDNC_gf_MMDragonballsTransmissionDragonExpireQ3_Trigger = null;

void libMDNC_gf_MMDragonballsTransmissionDragonExpireQ3 () {
    if (auto_libMDNC_gf_MMDragonballsTransmissionDragonExpireQ3_Trigger == null) {
        auto_libMDNC_gf_MMDragonballsTransmissionDragonExpireQ3_Trigger = TriggerCreate("auto_libMDNC_gf_MMDragonballsTransmissionDragonExpireQ3_TriggerFunc");
    }

    TriggerExecute(auto_libMDNC_gf_MMDragonballsTransmissionDragonExpireQ3_Trigger, false, false);
}

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

    TriggerQueueEnter();
    UserDataResetType("MapVOEvent");
    UserDataSetInt("MapVOEvent", "Gardens - Night Soon Repeat", "Value", 1, 1);
    ConversationDataRun("GardensofTerror", PlayerGroupAll(), c_conversationSkipNone, false);
    libCore_gf_WaitForConversationToFinish();
    TriggerQueueExit();
    return true;
}

trigger auto_libMDNC_gf_MMDragonballsTransmissionDragonExpireQ5_Trigger = null;

void libMDNC_gf_MMDragonballsTransmissionDragonExpireQ5 () {
    if (auto_libMDNC_gf_MMDragonballsTransmissionDragonExpireQ5_Trigger == null) {
        auto_libMDNC_gf_MMDragonballsTransmissionDragonExpireQ5_Trigger = TriggerCreate("auto_libMDNC_gf_MMDragonballsTransmissionDragonExpireQ5_TriggerFunc");
    }

    TriggerExecute(auto_libMDNC_gf_MMDragonballsTransmissionDragonExpireQ5_Trigger, false, false);
}

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

    TriggerQueueEnter();
    UserDataResetType("MapVOEvent");
    UserDataSetInt("MapVOEvent", "Gardens - Night Begins First", "Value", 1, 1);
    ConversationDataRun("GardensofTerror", PlayerGroupAll(), c_conversationSkipNone, false);
    libCore_gf_WaitForConversationToFinish();
    TriggerQueueExit();
    return true;
}

trigger auto_libMDNC_gf_MMDragonballsTransmissionDragonExpireQ4_Trigger = null;

void libMDNC_gf_MMDragonballsTransmissionDragonExpireQ4 () {
    if (auto_libMDNC_gf_MMDragonballsTransmissionDragonExpireQ4_Trigger == null) {
        auto_libMDNC_gf_MMDragonballsTransmissionDragonExpireQ4_Trigger = TriggerCreate("auto_libMDNC_gf_MMDragonballsTransmissionDragonExpireQ4_TriggerFunc");
    }

    TriggerExecute(auto_libMDNC_gf_MMDragonballsTransmissionDragonExpireQ4_Trigger, false, false);
}

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

    TriggerQueueEnter();
    UserDataResetType("MapVOEvent");
    UserDataSetInt("MapVOEvent", "Gardens - Night Begins Repeat", "Value", 1, 1);
    ConversationDataRun("GardensofTerror", PlayerGroupAll(), c_conversationSkipNone, false);
    libCore_gf_WaitForConversationToFinish();
    TriggerQueueExit();
    return true;
}

trigger auto_libMDNC_gf_MMGardenTerrorTransmissionNightEndsQ_Trigger = null;

void libMDNC_gf_MMGardenTerrorTransmissionNightEndsQ () {
    if (auto_libMDNC_gf_MMGardenTerrorTransmissionNightEndsQ_Trigger == null) {
        auto_libMDNC_gf_MMGardenTerrorTransmissionNightEndsQ_Trigger = TriggerCreate("auto_libMDNC_gf_MMGardenTerrorTransmissionNightEndsQ_TriggerFunc");
    }

    TriggerExecute(auto_libMDNC_gf_MMGardenTerrorTransmissionNightEndsQ_Trigger, false, false);
}

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

    TriggerQueueEnter();
    UserDataResetType("MapVOEvent");
    UserDataSetInt("MapVOEvent", "Gardens - Night Ends", "Value", 1, 1);
    ConversationDataRun("GardensofTerror", PlayerGroupAll(), c_conversationSkipNone, false);
    libCore_gf_WaitForConversationToFinish();
    TriggerQueueExit();
    return true;
}

trigger auto_libMDNC_gf_MMGardenTerrorTransmissionGolemStartGrowingQ_Trigger = null;
int auto_libMDNC_gf_MMGardenTerrorTransmissionGolemStartGrowingQ_lp_team;

void libMDNC_gf_MMGardenTerrorTransmissionGolemStartGrowingQ (int lp_team) {
    auto_libMDNC_gf_MMGardenTerrorTransmissionGolemStartGrowingQ_lp_team = lp_team;

    if (auto_libMDNC_gf_MMGardenTerrorTransmissionGolemStartGrowingQ_Trigger == null) {
        auto_libMDNC_gf_MMGardenTerrorTransmissionGolemStartGrowingQ_Trigger = TriggerCreate("auto_libMDNC_gf_MMGardenTerrorTransmissionGolemStartGrowingQ_TriggerFunc");
    }

    TriggerExecute(auto_libMDNC_gf_MMGardenTerrorTransmissionGolemStartGrowingQ_Trigger, false, false);
}

bool auto_libMDNC_gf_MMGardenTerrorTransmissionGolemStartGrowingQ_TriggerFunc (bool testConds, bool runActions) {
    int lp_team = auto_libMDNC_gf_MMGardenTerrorTransmissionGolemStartGrowingQ_lp_team;

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

    TriggerQueueEnter();
    UserDataResetType("MapVOEvent");
    if ((libMDNC_gv_mMGardenTerrorNightFallen == false)) {
        UserDataSetInt("MapVOEvent", "Gardens - 100 Seeds - Day", "Value", 1, 1);
    }
    else {
        UserDataSetInt("MapVOEvent", "Gardens - 100 Seeds - Night", "Value", 1, 1);
    }
    ConversationDataRun("GardensofTerror", libGame_gf_PlayersOnTeamHeroes(lp_team, false), c_conversationSkipNone, false);
    libCore_gf_WaitForConversationToFinish();
    TriggerQueueExit();
    return true;
}

trigger auto_libMDNC_gf_MMGardenTerrorTransmissionGolemWaitingQ_Trigger = null;
int auto_libMDNC_gf_MMGardenTerrorTransmissionGolemWaitingQ_lp_team;
int auto_libMDNC_gf_MMGardenTerrorTransmissionGolemWaitingQ_lp_stage;

void libMDNC_gf_MMGardenTerrorTransmissionGolemWaitingQ (int lp_team, int lp_stage) {
    auto_libMDNC_gf_MMGardenTerrorTransmissionGolemWaitingQ_lp_team = lp_team;
    auto_libMDNC_gf_MMGardenTerrorTransmissionGolemWaitingQ_lp_stage = lp_stage;

    if (auto_libMDNC_gf_MMGardenTerrorTransmissionGolemWaitingQ_Trigger == null) {
        auto_libMDNC_gf_MMGardenTerrorTransmissionGolemWaitingQ_Trigger = TriggerCreate("auto_libMDNC_gf_MMGardenTerrorTransmissionGolemWaitingQ_TriggerFunc");
    }

    TriggerExecute(auto_libMDNC_gf_MMGardenTerrorTransmissionGolemWaitingQ_Trigger, false, false);
}

bool auto_libMDNC_gf_MMGardenTerrorTransmissionGolemWaitingQ_TriggerFunc (bool testConds, bool runActions) {
    int lp_team = auto_libMDNC_gf_MMGardenTerrorTransmissionGolemWaitingQ_lp_team;
    int lp_stage = auto_libMDNC_gf_MMGardenTerrorTransmissionGolemWaitingQ_lp_stage;

    // Automatic Variable Declarations
    int auto9D1BC594_val;

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

    TriggerQueueEnter();
    UserDataResetType("MapVOEvent");
    auto9D1BC594_val = lp_stage;
    if (auto9D1BC594_val == 1) {
        if ((libMDNC_gv_mMGardenTerrorNightFallen == false)) {
            UserDataSetInt("MapVOEvent", "Gardens - Plant Waiting - Day", "Value", 1, 1);
        }
        else {
            UserDataSetInt("MapVOEvent", "Gardens - Plant Waiting - Night", "Value", 1, 1);
        }
    }
    else if (auto9D1BC594_val == 2) {
        if ((libMDNC_gv_mMGardenTerrorNightFallen == false)) {
            UserDataSetInt("MapVOEvent", "Gardens - Plant Waiting 2 - Day", "Value", 1, 1);
        }
        else {
            UserDataSetInt("MapVOEvent", "Gardens - Plant Waiting 2 - Night", "Value", 1, 1);
        }
    }
    else if (auto9D1BC594_val == 3) {
        if ((libMDNC_gv_mMGardenTerrorNightFallen == false)) {
            UserDataSetInt("MapVOEvent", "Gardens - Plant Waiting 3 - Day", "Value", 1, 1);
        }
        else {
            UserDataSetInt("MapVOEvent", "Gardens - Plant Waiting 3 - Night", "Value", 1, 1);
        }
    }
    else {
    }
    ConversationDataRun("GardensofTerror", libGame_gf_PlayersOnTeamHeroes(lp_team, false), c_conversationSkipNone, false);
    libCore_gf_WaitForConversationToFinish();
    TriggerQueueExit();
    return true;
}

trigger auto_libMDNC_gf_MMGardenTerrorTransmissionGolemWastedQ_Trigger = null;
int auto_libMDNC_gf_MMGardenTerrorTransmissionGolemWastedQ_lp_team;

void libMDNC_gf_MMGardenTerrorTransmissionGolemWastedQ (int lp_team) {
    auto_libMDNC_gf_MMGardenTerrorTransmissionGolemWastedQ_lp_team = lp_team;

    if (auto_libMDNC_gf_MMGardenTerrorTransmissionGolemWastedQ_Trigger == null) {
        auto_libMDNC_gf_MMGardenTerrorTransmissionGolemWastedQ_Trigger = TriggerCreate("auto_libMDNC_gf_MMGardenTerrorTransmissionGolemWastedQ_TriggerFunc");
    }

    TriggerExecute(auto_libMDNC_gf_MMGardenTerrorTransmissionGolemWastedQ_Trigger, false, false);
}

bool auto_libMDNC_gf_MMGardenTerrorTransmissionGolemWastedQ_TriggerFunc (bool testConds, bool runActions) {
    int lp_team = auto_libMDNC_gf_MMGardenTerrorTransmissionGolemWastedQ_lp_team;

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

    TriggerQueueEnter();
    UserDataResetType("MapVOEvent");
    if ((libMDNC_gv_mMGardenTerrorNightFallen == false)) {
        UserDataSetInt("MapVOEvent", "Gardens - Plant Lost - Day", "Value", 1, 1);
    }
    else {
        UserDataSetInt("MapVOEvent", "Gardens - Plant Lost - Night", "Value", 1, 1);
    }
    ConversationDataRun("GardensofTerror", libGame_gf_PlayersOnTeamHeroes(lp_team, false), c_conversationSkipNone, false);
    libCore_gf_WaitForConversationToFinish();
    TriggerQueueExit();
    return true;
}

trigger auto_libMDNC_gf_MMDragonballsTransmissionDragonActiveQ2_Trigger = null;
int auto_libMDNC_gf_MMDragonballsTransmissionDragonActiveQ2_lp_activeTeam;

void libMDNC_gf_MMDragonballsTransmissionDragonActiveQ2 (int lp_activeTeam) {
    auto_libMDNC_gf_MMDragonballsTransmissionDragonActiveQ2_lp_activeTeam = lp_activeTeam;

    if (auto_libMDNC_gf_MMDragonballsTransmissionDragonActiveQ2_Trigger == null) {
        auto_libMDNC_gf_MMDragonballsTransmissionDragonActiveQ2_Trigger = TriggerCreate("auto_libMDNC_gf_MMDragonballsTransmissionDragonActiveQ2_TriggerFunc");
    }

    TriggerExecute(auto_libMDNC_gf_MMDragonballsTransmissionDragonActiveQ2_Trigger, false, false);
}

bool auto_libMDNC_gf_MMDragonballsTransmissionDragonActiveQ2_TriggerFunc (bool testConds, bool runActions) {
    int lp_activeTeam = auto_libMDNC_gf_MMDragonballsTransmissionDragonActiveQ2_lp_activeTeam;

    // Variable Declarations
    playergroup lv_orderPlayerGroup;
    playergroup lv_chaosPlayerGroup;
    playergroup lv_observerPlayer;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_orderPlayerGroup = PlayerGroupEmpty();
    lv_chaosPlayerGroup = PlayerGroupEmpty();
    lv_observerPlayer = PlayerGroupEmpty();

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

    TriggerQueueEnter();
    UserDataResetType("MapVOEvent");
    ConversationDataLineResetPlayers("GardensofTerror", ("Left"));
    ConversationDataLineResetPlayers("GardensofTerror", ("Right"));
    ConversationDataLineResetPlayers("GardensofTerror", ("Observer"));
    if ((libMDNC_gv_mMGardenTerrorNightFallen == false)) {
        if ((lp_activeTeam == libGame_gv_teamOrderIndex_C)) {
            UserDataSetInt("MapVOEvent", "Gardens - Plant Spawned Left - Day", "Value", 1, 1);
        }
        else {
            UserDataSetInt("MapVOEvent", "Gardens - Plant Spawned Right - Day", "Value", 1, 1);
        }
    }
    else {
        if ((lp_activeTeam == libGame_gv_teamOrderIndex_C)) {
            UserDataSetInt("MapVOEvent", "Gardens - Plant Spawned Left - Night", "Value", 1, 1);
        }
        else {
            UserDataSetInt("MapVOEvent", "Gardens - Plant Spawned Right - Night", "Value", 1, 1);
        }
    }
    lv_orderPlayerGroup = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamOrderIndex_C, false);
    lv_chaosPlayerGroup = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamChaosIndex_C, false);
    lv_observerPlayer = libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer];
    ConversationDataLineSetPlayers("GardensofTerror", ("Left"), lv_orderPlayerGroup);
    ConversationDataLineSetPlayers("GardensofTerror", ("Right"), lv_chaosPlayerGroup);
    ConversationDataLineSetPlayers("GardensofTerror", ("Observer"), lv_observerPlayer);
    ConversationDataRun("GardensofTerror", PlayerGroupAll(), c_conversationSkipNone, false);
    libCore_gf_WaitForConversationToFinish();
    TriggerQueueExit();
    return true;
}

trigger auto_libMDNC_gf_MMDragonballsTransmissionDragonActiveQ3_Trigger = null;
int auto_libMDNC_gf_MMDragonballsTransmissionDragonActiveQ3_lp_activeTeam;

void libMDNC_gf_MMDragonballsTransmissionDragonActiveQ3 (int lp_activeTeam) {
    auto_libMDNC_gf_MMDragonballsTransmissionDragonActiveQ3_lp_activeTeam = lp_activeTeam;

    if (auto_libMDNC_gf_MMDragonballsTransmissionDragonActiveQ3_Trigger == null) {
        auto_libMDNC_gf_MMDragonballsTransmissionDragonActiveQ3_Trigger = TriggerCreate("auto_libMDNC_gf_MMDragonballsTransmissionDragonActiveQ3_TriggerFunc");
    }

    TriggerExecute(auto_libMDNC_gf_MMDragonballsTransmissionDragonActiveQ3_Trigger, false, false);
}

bool auto_libMDNC_gf_MMDragonballsTransmissionDragonActiveQ3_TriggerFunc (bool testConds, bool runActions) {
    int lp_activeTeam = auto_libMDNC_gf_MMDragonballsTransmissionDragonActiveQ3_lp_activeTeam;

    // Variable Declarations
    playergroup lv_orderPlayerGroup;
    playergroup lv_chaosPlayerGroup;
    playergroup lv_observerPlayer;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_orderPlayerGroup = PlayerGroupEmpty();
    lv_chaosPlayerGroup = PlayerGroupEmpty();
    lv_observerPlayer = PlayerGroupEmpty();

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

    TriggerQueueEnter();
    UserDataResetType("MapVOEvent");
    ConversationDataLineResetPlayers("GardensofTerror", ("Left"));
    ConversationDataLineResetPlayers("GardensofTerror", ("Right"));
    if ((libMDNC_gv_mMGardenTerrorNightFallen == false)) {
        if ((lp_activeTeam == libGame_gv_teamOrderIndex_C)) {
            UserDataSetInt("MapVOEvent", "Gardens - Plant Killed Left - Day", "Value", 1, 1);
        }
        else {
            UserDataSetInt("MapVOEvent", "Gardens - Plant Killed Right - Day", "Value", 1, 1);
        }
    }
    else {
        if ((lp_activeTeam == libGame_gv_teamOrderIndex_C)) {
            UserDataSetInt("MapVOEvent", "Gardens - Plant Killed Left - Night", "Value", 1, 1);
        }
        else {
            UserDataSetInt("MapVOEvent", "Gardens - Plant Killed Right - Night", "Value", 1, 1);
        }
    }
    lv_orderPlayerGroup = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamOrderIndex_C, false);
    lv_chaosPlayerGroup = libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamChaosIndex_C, false);
    ConversationDataLineSetPlayers("GardensofTerror", ("Left"), lv_orderPlayerGroup);
    ConversationDataLineSetPlayers("GardensofTerror", ("Right"), lv_chaosPlayerGroup);
    ConversationDataRun("GardensofTerror", PlayerGroupAll(), c_conversationSkipNone, false);
    libCore_gf_WaitForConversationToFinish();
    TriggerQueueExit();
    return true;
}

bool libMDNC_gf_IsNightTime () {
    // Automatic Variable Declarations
    // Implementation
    if ((libMDNC_gv_mMGardenTerrorNightFallen == true)) {
        return true;
    }
    else {
        return false;
    }
}

// Triggers
//--------------------------------------------------------------------------------------------------
// Trigger: MMGardenTerror Init
//--------------------------------------------------------------------------------------------------
bool libMDNC_gt_MMGardenTerrorInit_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_index;
    int lv_itPlayer;
    int lv_p;

    // Automatic Variable Declarations
    playergroup autoE8E10BEF_g;

    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((libGame_gf_MapMechanicInitializationMechanicType() == libMDNC_gv_mMGardenTerrorMechanicName_C))) {
            return false;
        }
    }

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

    TriggerEnable(libMDNC_gt_MMGardenTerrorGatesOpened, true);
    TriggerEnable(libMDNC_gt_MMGardenTerrorNightMonsterDies, true);
    TriggerEnable(libMDNC_gt_MMGardenTerrorSeedDropped, true);
    TriggerEnable(libMDNC_gt_MMGardenTerrorSeedPickup, true);
    TriggerEnable(libMDNC_gt_MMGardenTerrorGolemSummonStarted, true);
    TriggerEnable(libMDNC_gt_MMGardenTerrorGolemSummoned, true);
    TriggerEnable(libMDNC_gt_MMGardenTerrorChannelStarted, true);
    TriggerEnable(libMDNC_gt_MMGardenTerrorDebugTemp, true);
    TriggerEnable(libMDNC_gt_MMGardenTerrorDebugStart, true);
    TriggerEnable(libMDNC_gt_MMGardenTerrorDebugStart1, true);
    TriggerEnable(libMDNC_gt_MMGardenTerrorDebugNightEnds, true);
    TriggerEnable(libMDNC_gt_MMGardenTerrorDebugAlwaysDay, true);
    TriggerEnable(libMDNC_gt_MMGardenTerrorDebugAlwaysNight, true);
    libGame_gf_SendMapSpecificAwardInitializeEventwithUserData(null, "Generic Instance");
    TriggerEnable(libMDNC_gt_MMGardenTerrorChannelCompleted, true);
    ActorSend(libMapM_gv_mapMechanicControllerActor, "Signal MM1Off");
    libMDNC_gv_mMGardenTerrorDays = 1;
    libMDNC_gf_MMGardenTerrorNightMonstersDroppingSeeds();
    SoundtrackPlay(PlayerGroupAll(), c_soundtrackCategoryAmbience, "Amb_2D_GardenOfTerror_Day", c_soundtrackCueAny, c_soundtrackIndexAny, false);
    SoundChannelMute(PlayerGroupAll(), c_soundCategoryUser14, true);
    SoundChannelMute(PlayerGroupAll(), c_soundCategorySPieces, false);
    SoundChannelMute(PlayerGroupAll(), c_soundCategoryMessage, false);
    libCore_gv_mAPMapLight = "StormGardenofTerrorDay";
    GameSetLighting(libCore_gv_mAPMapLight, 0.0);
    libMDNC_gf_MMGardenTerrorCreateHauntedGardens();
    UnitSetFacing(libMDNC_gv_mMGardenTerrorGarden[libGame_gv_teamOrderIndex_C].lv_fertileSoil, libMDNC_gv_mMGardenTerrorGarden[libGame_gv_teamOrderIndex_C].lv_facing, 0.0);
    UnitSetFacing(libMDNC_gv_mMGardenTerrorGarden[libGame_gv_teamChaosIndex_C].lv_fertileSoil, libMDNC_gv_mMGardenTerrorGarden[libGame_gv_teamChaosIndex_C].lv_facing, 0.0);
    autoE8E10BEF_g = PlayerGroupAll();
    lv_itPlayer = -1;
    while (true) {
        	lv_itPlayer = PlayerGroupNextPlayer(autoE8E10BEF_g, lv_itPlayer);
        	if (lv_itPlayer<0) { break; }
        	CatalogFieldValueSet(c_gameCatalogEffect, "UseVehiclePersistent", "PeriodCount", lv_itPlayer, FixedToString((libMDNC_gv_mMGardenTerrorVehicleChannelTime_C / 0.125), c_fixedPrecisionAny));
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMDNC_gt_MMGardenTerrorInit_Init () {
    libMDNC_gt_MMGardenTerrorInit = TriggerCreate("libMDNC_gt_MMGardenTerrorInit_Func");
    libGame_gf_MapMechanicInitialization(libMDNC_gt_MMGardenTerrorInit);
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMGardenTerror Ping Data Init
//--------------------------------------------------------------------------------------------------
bool libMDNC_gt_MMGardenTerrorPingDataInit_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libUIUI_gf_PingCreateNewPingTarget("VehiclePlantHorror", false, null, StringExternal("Param/Value/lib_MDNC_060B543B"), StringExternal("Param/Value/lib_MDNC_8508E035"), SoundLink("UI_Game_Ping_General", -1), SoundLink("UI_Game_Ping_General", -1));
    libUIUI_gf_PingCreateNewPingTarget("VehiclePlantHorror", true, null, StringExternal("Param/Value/lib_MDNC_46913147"), StringExternal("Param/Value/lib_MDNC_66662862"), SoundLink("UI_Game_Ping_Help", -1), SoundLink("UI_Game_Ping_Attack", -1));
    libUIUI_gf_PingCreateNewPingTarget("JunglePlantHorror", false, null, StringExternal("Param/Value/lib_MDNC_DF327029"), StringExternal("Param/Value/lib_MDNC_A8FCEB4D"), SoundLink("UI_Game_Ping_Attack", -1), SoundLink("UI_Game_Ping_Attack", -1));
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMDNC_gt_MMGardenTerrorPingDataInit_Init () {
    libMDNC_gt_MMGardenTerrorPingDataInit = TriggerCreate("libMDNC_gt_MMGardenTerrorPingDataInit_Func");
    libCore_gf_IncludeModInitialization(libMDNC_gt_MMGardenTerrorPingDataInit);
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMGardenTerror Announcer Init
//--------------------------------------------------------------------------------------------------
bool libMDNC_gt_MMGardenTerrorAnnouncerInit_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libCore_gf_DataAnnouncerVOSetDefaultAnnouncerForPlayerGroup(PlayerGroupAll(), "GardensDayAnnouncer");
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMDNC_gt_MMGardenTerrorAnnouncerInit_Init () {
    libMDNC_gt_MMGardenTerrorAnnouncerInit = TriggerCreate("libMDNC_gt_MMGardenTerrorAnnouncerInit_Func");
    libCore_gf_IncludeModInitialization(libMDNC_gt_MMGardenTerrorAnnouncerInit);
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMGardenTerror Gates Opened
//--------------------------------------------------------------------------------------------------
bool libMDNC_gt_MMGardenTerrorGatesOpened_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((libMapM_gv_mMMapMechanicDisabled == false))) {
            return false;
        }
    }

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

    libMDNC_gf_MMGardenTerrorManageSummonBossPing(libGame_gv_teamOrderIndex_C);
    libMDNC_gf_MMGardenTerrorManageSummonBossPing(libGame_gv_teamChaosIndex_C);
    Wait(libMDNC_gv_mMGardenTerrorStartTime_C, c_timeGame);
    if (((TriggerIsEnabled(TriggerGetCurrent()) == false) || (libMDNC_gv_mMGardenTerrorDebugAlways > 0))) {
        return true;
    }

    libMDNC_gf_MMGardenTerrorNightPrepare();
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMDNC_gt_MMGardenTerrorGatesOpened_Init () {
    libMDNC_gt_MMGardenTerrorGatesOpened = TriggerCreate("libMDNC_gt_MMGardenTerrorGatesOpened_Func");
    TriggerEnable(libMDNC_gt_MMGardenTerrorGatesOpened, false);
    TriggerAddEventTimer(libMDNC_gt_MMGardenTerrorGatesOpened, libGame_gv_openTheGatesTimer);
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMGardenTerror Night Starts
//--------------------------------------------------------------------------------------------------
bool libMDNC_gt_MMGardenTerrorNightStarts_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((libMDNC_gv_mMGardenTerrorDebugAlways == 0))) {
            return false;
        }
    }

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

    libMDNC_gf_MMGardenTerrorNightStarts();
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMDNC_gt_MMGardenTerrorNightStarts_Init () {
    libMDNC_gt_MMGardenTerrorNightStarts = TriggerCreate("libMDNC_gt_MMGardenTerrorNightStarts_Func");
    TriggerAddEventTimer(libMDNC_gt_MMGardenTerrorNightStarts, libMDNC_gv_mMGardenTerrorPrepTimer);
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMGardenTerror Night Start Light Transition
//--------------------------------------------------------------------------------------------------
bool libMDNC_gt_MMGardenTerrorNightStartLightTransition_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_itPlayer;

    // Automatic Variable Declarations
    // Variable Initialization

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

    libGame_gf_SpecialLightingEventStart("StormGardenofTerrorTransition", PlayerGroupAll(), 1.0);
    libNtve_gf_WaitForTimer(libMDNC_gv_mMGardenTerrorPrepTimer, 2.0, false);
    libGame_gf_SpecialLightingEventEnd("StormGardenofTerrorTransition", PlayerGroupAll(), 0.0);
    libGame_gf_SpecialLightingEventStart("StormGardenofTerrorNight", PlayerGroupAll(), 2.0);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMDNC_gt_MMGardenTerrorNightStartLightTransition_Init () {
    libMDNC_gt_MMGardenTerrorNightStartLightTransition = TriggerCreate("libMDNC_gt_MMGardenTerrorNightStartLightTransition_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMGardenTerror Night End Light Transition
//--------------------------------------------------------------------------------------------------
bool libMDNC_gt_MMGardenTerrorNightEndLightTransition_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_itPlayer;

    // Automatic Variable Declarations
    // Variable Initialization

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

    libGame_gf_SpecialLightingEventEnd("StormGardenofTerrorNight", PlayerGroupAll(), 2.0);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMDNC_gt_MMGardenTerrorNightEndLightTransition_Init () {
    libMDNC_gt_MMGardenTerrorNightEndLightTransition = TriggerCreate("libMDNC_gt_MMGardenTerrorNightEndLightTransition_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMGardenTerror Night Monster Dies
//--------------------------------------------------------------------------------------------------
bool libMDNC_gt_MMGardenTerrorNightMonsterDies_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_groupIndex;
    int lv_regenGlobeOwner;
    int lv_itGroupIndex;
    int lv_itBoss;
    int lv_bossIndex;

    // Automatic Variable Declarations
    int auto3FA66312_ae;
    const int auto3FA66312_ai = 1;

    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!(((UnitGetType(EventUnit()) == "JunglePlantHorror") || (UnitGetType(EventUnit()) == "Shambler") || (UnitGetType(EventUnit()) == "ShamblerRanged")))) {
            return false;
        }
    }

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

    if ((UnitGetType(EventUnit()) == "JunglePlantHorror")) {
        auto3FA66312_ae = libMDNC_gv_mMGardenTerrorNightBossesCount;
        lv_itBoss = 1;
        for ( ; ( (auto3FA66312_ai >= 0 && lv_itBoss <= auto3FA66312_ae) || (auto3FA66312_ai < 0 && lv_itBoss >= auto3FA66312_ae) ) ; lv_itBoss += auto3FA66312_ai ) {
            if ((libMDNC_gv_mMGardenTerrorNightBosses[lv_itBoss].lv_unit == EventUnit())) {
                UnitRemove(libMDNC_gv_mMGardenTerrorNightBosses[lv_itBoss].lv_unit2);
                libGame_gf_DropLootBannerinSconce(libMDNC_gv_mMGardenTerrorNightBosses[lv_itBoss].lv_bannerSconce, libGame_gv_players[libNtve_gf_KillingPlayer()].lv_lootContent.lv_loot_Banner.lv_bannerID, libNtve_gf_KillingPlayer(), true);
                lv_bossIndex = lv_itBoss;
                break;
            }

        }
        if ((lv_bossIndex == 0)) {
            return true;
        }

        libMDNC_gf_MMGardenTerrorNightBossDropsSeeds(lv_bossIndex);
        libMDNC_gf_MMGardenTerrorDropSeeds(UnitGetPosition(EventUnit()), libMDNC_gv_mMGardenTerrorDropSeedsBossFinalDrop_C, true);
        UnitCreateEffectPoint(EventUnit(), "RegenGlobeNeutralCreatePrecursorUnit", RegionRandomPoint(RegionCircle(UnitGetPosition(EventUnit()), 4.5)));
    }
    else {
        libMDNC_gf_MMGardenTerrorNightMinionDropsSeeds(EventUnit());
        libMDNC_gf_MMGardenTerrorDropSeeds(UnitGetPosition(EventUnit()), libMDNC_gv_mMGardenTerrorDropSeedsMinionFinalDrop_C, false);
        lv_itGroupIndex = libMDNC_gf_MMGardenTerrorNightMinionGroupIndex(EventUnit());
        if ((libNtve_gf_UnitGroupIsDead(libMDNC_gv_mMGardenTerrorNightMinionGroups[lv_itGroupIndex].lv_units) == true)) {
            UnitRemove(libMDNC_gv_mMGardenTerrorNightMinionGroupIcons[lv_itGroupIndex]);
            libMDNC_gv_mMGardenTerrorNightMinionGroupIcons[lv_itGroupIndex] = null;
            libGame_gf_DropLootBannerinSconce(libMDNC_gv_mMGardenTerrorNightMinionGroups[lv_itGroupIndex].lv_bannerSconce, libGame_gv_players[libNtve_gf_KillingPlayer()].lv_lootContent.lv_loot_Banner.lv_bannerID, libNtve_gf_KillingPlayer(), true);
        }

    }
    libMDNC_gv_mMGardenTerrorNightMonstersTotalCount -= 1;
    if ((libNtve_gf_UnitGroupIsDead(libMDNC_gv_mMGardenTerrorNightMonsters) == true)) {
        Wait(3.0, c_timeGame);
        libMDNC_gf_MMGardenTerrorNightEnds();
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libMDNC_gt_MMGardenTerrorNightMonsterDies_Init () {
    libMDNC_gt_MMGardenTerrorNightMonsterDies = TriggerCreate("libMDNC_gt_MMGardenTerrorNightMonsterDies_Func");
    TriggerEnable(libMDNC_gt_MMGardenTerrorNightMonsterDies, false);
    TriggerAddEventUnitDied(libMDNC_gt_MMGardenTerrorNightMonsterDies, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMGardenTerror Seed Dropped
//--------------------------------------------------------------------------------------------------
bool libMDNC_gt_MMGardenTerrorSeedDropped_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_itTeam;
    bool[3] lv_visionShared;

    // Automatic Variable Declarations
    const int auto8EA0091C_ae = 2;
    const int auto8EA0091C_ai = 1;

    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((UnitGetType(EventUnitCreatedUnit()) == "ItemSeedPickup"))) {
            return false;
        }
    }

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

    SoundPlayAtPointForPlayer(SoundLink("UI_SeedPickup_Drop", -1), c_maxPlayers, PlayerGroupAll(), UnitGetPosition(EventUnitCreatedUnit()), 0.0, 100.0, 0.5);
    AIAddCollectable(EventUnitCreatedUnit(), "CollectSeed", 1.0);
    while (true) {
        if ((UnitIsAlive(EventUnitCreatedUnit()) == false)) {
            return true;
        }

        lv_itTeam = 1;
        for ( ; ( (auto8EA0091C_ai >= 0 && lv_itTeam <= auto8EA0091C_ae) || (auto8EA0091C_ai < 0 && lv_itTeam >= auto8EA0091C_ae) ) ; lv_itTeam += auto8EA0091C_ai ) {
            if ((lv_visionShared[lv_itTeam] == false) && (libNtve_gf_UnitIsVisibleToPlayer(EventUnitCreatedUnit(), libGame_gf_ComputerPlayerInTeam(lv_itTeam)) == true)) {
                libNtve_gf_ShareVisionofUnit(EventUnitCreatedUnit(), true, libGame_gf_ComputerPlayerInTeam(lv_itTeam));
                lv_visionShared[lv_itTeam] = true;
                if ((lv_visionShared[1] == true) && (lv_visionShared[2] == true)) {
                    return true;
                }

            }

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

//--------------------------------------------------------------------------------------------------
void libMDNC_gt_MMGardenTerrorSeedDropped_Init () {
    libMDNC_gt_MMGardenTerrorSeedDropped = TriggerCreate("libMDNC_gt_MMGardenTerrorSeedDropped_Func");
    TriggerEnable(libMDNC_gt_MMGardenTerrorSeedDropped, false);
    TriggerAddEventUnitCreated(libMDNC_gt_MMGardenTerrorSeedDropped, null, null, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMGardenTerror Seed Pickup
//--------------------------------------------------------------------------------------------------
bool libMDNC_gt_MMGardenTerrorSeedPickup_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_collectingPlayer;
    unit lv_collectingUnit;
    playergroup lv_textTagPlayers;
    int lv_alliedSeedsCollected;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_textTagPlayers = PlayerGroupEmpty();

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

    lv_collectingPlayer = EventPlayerEffectUsedUnitOwner(c_effectPlayerTarget);
    lv_collectingUnit = EventPlayerEffectUsedUnit(c_effectUnitTarget);
    libGame_gf_SendEventMapGardenOfTerrorSeedsCollected(lv_collectingPlayer);
    libMDNC_gv_mMGardenTerrorSeedsCollected[libGame_gf_TeamNumberOfPlayer(lv_collectingPlayer)] += 1;
    libMDNC_gv_mMGardenTerrorSeedsCollectedTonight[libGame_gf_TeamNumberOfPlayer(lv_collectingPlayer)] += 1;
    lv_alliedSeedsCollected = libMDNC_gv_mMGardenTerrorSeedsCollected[libGame_gf_TeamNumberOfPlayer(lv_collectingPlayer)];
    SoundPlayAtPointForPlayer(SoundLink("UI_SeedPickup_Pickup", -1), c_maxPlayers, PlayerGroupAll(), UnitGetPosition(lv_collectingUnit), 0.5, 100.0, 0.0);
    libNtve_gf_AddPlayerGroupToPlayerGroup(libGame_gf_AlliedPlayerGroupOfPlayer(lv_collectingPlayer), lv_textTagPlayers);
    PlayerGroupAdd(lv_textTagPlayers, libCore_gv_oBSERVER_ObserverUIPlayer);
    TextTagCreate(StringExternal("Param/Value/lib_MDNC_C760B91E"), 24, UnitGetPosition(lv_collectingUnit), 1.0, true, true, lv_textTagPlayers);
    TextTagSetVelocity(TextTagLastCreated(), 1.5, 90.0);
    TextTagSetTime(TextTagLastCreated(), c_textTagTimeDuration, 3.0);
    TextTagSetFogVisibility(TextTagLastCreated(), c_visTypeFog);
    TextTagCreate(StringExternal("Param/Value/lib_MDNC_C9763548"), 24, UnitGetPosition(lv_collectingUnit), 1.0, true, true, libGame_gf_EnemyPlayerGroupOfPlayer(lv_collectingPlayer));
    TextTagSetVelocity(TextTagLastCreated(), 1.5, 90.0);
    TextTagSetTime(TextTagLastCreated(), c_textTagTimeDuration, 3.0);
    TextTagSetFogVisibility(TextTagLastCreated(), c_visTypeFog);
    libMDNC_gf_MMGardenTerrorUpdateHauntedGarden(1);
    libMDNC_gf_MMGardenTerrorUpdateHauntedGarden(2);
    if (((lv_alliedSeedsCollected == 100) || (lv_alliedSeedsCollected == 200) || (lv_alliedSeedsCollected == 300))) {
        libGame_gf_SendEventMapObjectiveCapturedByUnit(lv_collectingUnit);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libMDNC_gt_MMGardenTerrorSeedPickup_Init () {
    libMDNC_gt_MMGardenTerrorSeedPickup = TriggerCreate("libMDNC_gt_MMGardenTerrorSeedPickup_Func");
    TriggerEnable(libMDNC_gt_MMGardenTerrorSeedPickup, false);
    TriggerAddEventPlayerEffectUsed(libMDNC_gt_MMGardenTerrorSeedPickup, c_playerAny, "SeedPickupSet");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMGardenTerror Night Vignette
//--------------------------------------------------------------------------------------------------
bool libMDNC_gt_MMGardenTerrorNightVignette_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_itPlayer;

    // Automatic Variable Declarations
    const int auto2B8529BD_ae = libCore_gv_bALMaxPlayers;
    const int auto2B8529BD_ai = 1;

    // Variable Initialization

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

    lv_itPlayer = 1;
    for ( ; ( (auto2B8529BD_ai >= 0 && lv_itPlayer <= auto2B8529BD_ae) || (auto2B8529BD_ai < 0 && lv_itPlayer >= auto2B8529BD_ae) ) ; lv_itPlayer += auto2B8529BD_ai ) {
        libUIUI_gf_VignetteOverlayPlayForPlayer(lv_itPlayer, "Cutscenes\\GameUI_GlobalVignetteOverlay.StormCutscene");
    }
    libUIUI_gf_VignetteOverlayPlayForPlayer(libCore_gv_oBSERVER_ObserverUIPlayer, "Cutscenes\\GameUI_GlobalVignetteOverlay.StormCutscene");
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMDNC_gt_MMGardenTerrorNightVignette_Init () {
    libMDNC_gt_MMGardenTerrorNightVignette = TriggerCreate("libMDNC_gt_MMGardenTerrorNightVignette_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMGardenTerror Plant Damage Calculation
//--------------------------------------------------------------------------------------------------
bool libMDNC_gt_MMGardenTerrorPlantDamageCalculation_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_damagingPlayer;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_damagingPlayer = EventUnitDamageSourcePlayer();

    // Conditions
    if (testConds) {
        if (!(((UnitGetType(EventUnit()) == "JunglePlantHorror") || (UnitGetType(EventUnit()) == "PlantZombie") || (UnitGetType(EventUnit()) == "PlantZombieRanged")))) {
            return false;
        }

        if (!((lv_damagingPlayer > 0))) {
            return false;
        }

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

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

    libMDNC_gv_mMGardenTerrorPlantDamageTotal[lv_damagingPlayer] = (libMDNC_gv_mMGardenTerrorPlantDamageTotal[lv_damagingPlayer] + EventUnitDamageAmount());
    libGame_gf_SendMapSpecificAwardEvent(lv_damagingPlayer, libMDNC_gv_mMGardenTerrorPlantDamageTotal[lv_damagingPlayer], false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMDNC_gt_MMGardenTerrorPlantDamageCalculation_Init () {
    libMDNC_gt_MMGardenTerrorPlantDamageCalculation = TriggerCreate("libMDNC_gt_MMGardenTerrorPlantDamageCalculation_Func");
    TriggerEnable(libMDNC_gt_MMGardenTerrorPlantDamageCalculation, false);
    TriggerAddEventUnitDamaged(libMDNC_gt_MMGardenTerrorPlantDamageCalculation, null, c_unitDamageTypeAny, c_unitDamageEither, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMGardenTerror Plant Damage Report
//--------------------------------------------------------------------------------------------------
bool libMDNC_gt_MMGardenTerrorPlantDamageReport_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_iterator;

    // Automatic Variable Declarations
    int auto26546472_ae;

    // Variable Initialization

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

    auto26546472_ae = libCore_gv_bALMaxPlayers;
    lv_iterator = 1;
    for ( ; lv_iterator <= auto26546472_ae ; lv_iterator += 1 ) {
        libGame_gf_ScoreValuesReportRealValueAndLog(lv_iterator, "GardensPlantDamage", libMDNC_gv_mMGardenTerrorPlantDamageTotal[lv_iterator]);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMDNC_gt_MMGardenTerrorPlantDamageReport_Init () {
    libMDNC_gt_MMGardenTerrorPlantDamageReport = TriggerCreate("libMDNC_gt_MMGardenTerrorPlantDamageReport_Func");
    libGame_gf_GameOverEvent(libMDNC_gt_MMGardenTerrorPlantDamageReport);
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMGardenTerror Channel Started
//--------------------------------------------------------------------------------------------------
bool libMDNC_gt_MMGardenTerrorChannelStarted_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libNtve_gf_SendActorMessageToUnit(EventUnitTargetUnit(), "Signal ChannelStart");
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMDNC_gt_MMGardenTerrorChannelStarted_Init () {
    libMDNC_gt_MMGardenTerrorChannelStarted = TriggerCreate("libMDNC_gt_MMGardenTerrorChannelStarted_Func");
    TriggerEnable(libMDNC_gt_MMGardenTerrorChannelStarted, false);
    TriggerAddEventUnitAbility(libMDNC_gt_MMGardenTerrorChannelStarted, null, AbilityCommand("UseVehicle", 0), c_abilEffectStageChannel, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMGardenTerror Channel Completed
//--------------------------------------------------------------------------------------------------
bool libMDNC_gt_MMGardenTerrorChannelCompleted_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_team;
    actor lv_light;

    // Automatic Variable Declarations
    // Variable Initialization

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

    lv_team = libGame_gf_TeamNumberOfPlayer(EventPlayer());
    UnitBehaviorRemove(libMDNC_gv_mMGardenTerrorSummonedBoss[lv_team], "PlantHorrorBirth", 1);
    UnitCreateEffectUnit(EventPlayerEffectUsedUnit(c_effectUnitCaster), "UseVehiclePropagateOrders", EventPlayerEffectUsedUnit(c_effectUnitTarget));
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMDNC_gt_MMGardenTerrorChannelCompleted_Init () {
    libMDNC_gt_MMGardenTerrorChannelCompleted = TriggerCreate("libMDNC_gt_MMGardenTerrorChannelCompleted_Func");
    TriggerEnable(libMDNC_gt_MMGardenTerrorChannelCompleted, false);
    TriggerAddEventPlayerEffectUsed(libMDNC_gt_MMGardenTerrorChannelCompleted, c_playerAny, "UseVehicleCastCompleteSet");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMGardenTerror Golem Summon Started
//--------------------------------------------------------------------------------------------------
bool libMDNC_gt_MMGardenTerrorGolemSummonStarted_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_team;

    // Automatic Variable Declarations
    // Variable Initialization

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

    lv_team = libGame_gf_TeamNumberOfPlayer(UnitGetOwner(EventUnit()));
    UnitAbilitySpendExplicit(libMDNC_gv_mMGardenTerrorSummonedBoss[lv_team], AbilityCommand("LeaveVehicle", 0), c_spendLocationAbility, 1.0, 1.0, 1.0, 1.0);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMDNC_gt_MMGardenTerrorGolemSummonStarted_Init () {
    libMDNC_gt_MMGardenTerrorGolemSummonStarted = TriggerCreate("libMDNC_gt_MMGardenTerrorGolemSummonStarted_Func");
    TriggerEnable(libMDNC_gt_MMGardenTerrorGolemSummonStarted, false);
    TriggerAddEventUnitAbility(libMDNC_gt_MMGardenTerrorGolemSummonStarted, null, AbilityCommand("UseVehicle", 0), c_abilEffectStageChannel, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMGardenTerror Golem Summoned
//--------------------------------------------------------------------------------------------------
bool libMDNC_gt_MMGardenTerrorGolemSummoned_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_team;
    int lv_enemyTeam;
    actor lv_light;
    fixed lv_duration;

    // Automatic Variable Declarations
    // Variable Initialization

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

    lv_team = libGame_gf_TeamNumberOfPlayer(EventPlayer());
    if ((libGame_gf_TeamNumberIsValid(lv_team) == false)) {
        return true;
    }

    libMDNC_gv_mMGardenTerrorPlayerSummoned[EventPlayer()] = true;
    lv_enemyTeam = libGame_gf_EnemyTeam(lv_team);
    libMDNC_gv_mMGardenTerrorSummonedBoss[lv_team] = EventPlayerEffectUsedUnit(c_effectUnitTarget);
    libMDNC_gv_mMGardenTerrorBossSummoned[lv_team] = true;
    libMDNC_gv_mMGardenTerrorNumberOfBossesSummoned += 1;
    libNtve_gf_SendActorMessageToUnit(libMDNC_gv_mMGardenTerrorSummonedBoss[lv_team], "SetMinimapVisibility 1");
    libNtve_gf_SendActorMessageToUnit(libMDNC_gv_mMGardenTerrorSummonedBoss[lv_team], "Signal VehicleEntered");
    UnitAbilitySpendExplicit(libMDNC_gv_mMGardenTerrorSummonedBoss[lv_team], AbilityCommand("LeaveVehicle", 0), c_spendLocationAbility, 1.0, 1.0, 1.0, 1.0);
    libNtve_gf_UnitAbilityRemoveCooldown(libMapM_gv_mMGardensDragonStatue, "LeaveVehicle", "Abil/LeaveVehicle");
    UnitAbilityAddCooldown(libMapM_gv_mMGardensDragonStatue, "LeaveVehicle", "Abil/LeaveVehicle", 5.0);
    UnitSetState(libMDNC_gv_mMGardenTerrorSummonedBoss[lv_team], c_unitStateTooltipable, false);
    libNtve_gf_MakeUnitInvulnerable(libMDNC_gv_mMGardenTerrorSummonedBoss[lv_team], false);
    UnitStatusBarOverride(libMDNC_gv_mMGardenTerrorSummonedBoss[lv_team], c_unitStatusGroupAll);
    RemoveUnitOfInterest(EventPlayerEffectUsedUnit(c_effectUnitTarget), "EnterGardenTerror", libAIAI_gf_ConvertIntegertoGoalTeam(lv_team));
    AddUnitOfInterest(EventPlayerEffectUsedUnit(c_effectUnitTarget), 0.0, 0.0, "EscortGardenTerror", libAIAI_gf_ConvertIntegertoGoalTeam(lv_team), 0);
    AddUnitOfInterest(EventPlayerEffectUsedUnit(c_effectUnitTarget), 0.0, 0.0, "KillEnemyGardenTerror", libAIAI_gf_ConvertIntegertoGoalTeam(lv_enemyTeam), 0);
    UnitBehaviorAdd(libMDNC_gv_mMGardenTerrorSummonedBoss[lv_team], "PlantHorrorTimedLife", EventPlayerEffectUsedUnit(c_effectUnitCaster), 1);
    lv_duration = libMDNC_gf_MMGardenTerrorSummonedGolemDuration();
    UnitBehaviorSetDuration(libMDNC_gv_mMGardenTerrorSummonedBoss[lv_team], "PlantHorrorTimedLife", lv_duration);
    UnitBehaviorSetDurationRemaining(libMDNC_gv_mMGardenTerrorSummonedBoss[lv_team], "PlantHorrorTimedLife", lv_duration);
    if ((libCore_gf_TextTagStoredForUnit(libMDNC_gv_mMGardenTerrorGarden[lv_team].lv_units, 1) != c_textTagNone)) {
        TextTagDestroy(libCore_gf_TextTagStoredForUnit(libMDNC_gv_mMGardenTerrorGarden[lv_team].lv_units, 1));
        libCore_gf_StoreTextTagForUnit(libMDNC_gv_mMGardenTerrorGarden[lv_team].lv_units, 1, c_textTagNone);
    }

    if ((libMDNC_gv_mMGardenTerrorGarden[lv_team].lv_units == libMDNC_gv_mMGardenTerrorSummonedBoss[lv_team])) {
        libMDNC_gv_mMGardenTerrorGarden[lv_team].lv_units = null;
    }

    libMDNC_gf_MMGardenTerrorUpdateHauntedGarden(lv_team);
    TriggerEnable(libMDNC_gt_MMGardenTerrorSummonedGolemKilled, true);
    libMDNC_gf_MMGardenTerrorUpdateCampHibernating();
    StatEventCreate("GardenTerrorActivated");
    StatEventAddDataFixed(StatEventLastCreated(), "Event", libMDNC_gv_mMGardenTerrorNumberOfBossesSummoned);
    StatEventAddDataFixed(StatEventLastCreated(), "TeamID", lv_team);
    StatEventSend(StatEventLastCreated());
    TriggerExecute(libMDNC_gt_MMGardenTerrorUIUpdateSummonedBossBar, true, false);
    libCore_gf_CreateMinimapPingStorm(libGame_gf_PlayersOnTeamHeroes(lv_team, false), "StormAlert", libMDNC_gv_mMGardenTerrorGarden[lv_team].lv_positions, Color(0.00, 100.00, 0.00), 6.0);
    PingSetUnit(PingLastCreated(), libMDNC_gv_mMGardenTerrorSummonedBoss[lv_team]);
    libCore_gf_CreateMinimapPingStorm(libGame_gf_PlayersOnTeamHeroes(lv_enemyTeam, false), "StormAlert", libMDNC_gv_mMGardenTerrorGarden[lv_team].lv_positions, Color(100.00, 0.00, 0.00), 6.0);
    PingSetUnit(PingLastCreated(), libMDNC_gv_mMGardenTerrorSummonedBoss[lv_team]);
    libMDNC_gf_MMDragonballsTransmissionDragonActiveQ2(lv_team);
    libGame_gf_AnnouncementAddItemForPlayerGroup(libGame_gf_PlayersOnTeamHeroes(lv_team, false), libGame_ge_AnnouncementPriorities_Critical, libCore_ge_AnnouncerVOEvents_Null, "DragonKnightAlly", StringExternal("Param/Value/lib_MDNC_CF799970"), StringToText(""), null, null, null, libGame_gv_announcement_StandardTimerDuration_C, false);
    libGame_gf_AnnouncementAddItemForPlayerGroup(libGame_gf_PlayersOnTeamHeroes(lv_enemyTeam, false), libGame_ge_AnnouncementPriorities_Critical, libCore_ge_AnnouncerVOEvents_Null, "DragonKnightEnemy", StringExternal("Param/Value/lib_MDNC_58DD3852"), StringToText(""), null, null, null, libGame_gv_announcement_StandardTimerDuration_C, false);
    if ((lv_team == libGame_gv_teamOrderIndex_C)) {
        libGame_gf_AnnouncementAddItemForPlayerGroup(libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer], libGame_ge_AnnouncementPriorities_Normal, libCore_ge_AnnouncerVOEvents_Null, "RavenCurseBegin", StringExternal("Param/Value/lib_MDNC_335FD6C0"), StringToText(""), null, null, null, libGame_gv_announcement_StandardTimerDuration_C, false);
    }
    else {
        libGame_gf_AnnouncementAddItemForPlayerGroup(libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer], libGame_ge_AnnouncementPriorities_Normal, libCore_ge_AnnouncerVOEvents_Null, "RavenCurseBegin", StringExternal("Param/Value/lib_MDNC_2FDC431E"), StringToText(""), null, null, null, libGame_gv_announcement_StandardTimerDuration_C, false);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMDNC_gt_MMGardenTerrorGolemSummoned_Init () {
    libMDNC_gt_MMGardenTerrorGolemSummoned = TriggerCreate("libMDNC_gt_MMGardenTerrorGolemSummoned_Func");
    TriggerEnable(libMDNC_gt_MMGardenTerrorGolemSummoned, false);
    TriggerAddEventPlayerEffectUsed(libMDNC_gt_MMGardenTerrorGolemSummoned, c_playerAny, "UseVehicleCastCompleteSet");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMGardenTerror Summoned Golem Killed
//--------------------------------------------------------------------------------------------------
bool libMDNC_gt_MMGardenTerrorSummonedGolemKilled_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_player;
    int lv_team;
    int lv_enemyTeam;
    int lv_cooldownTextTag;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_cooldownTextTag = c_textTagNone;

    // Conditions
    if (testConds) {
        if (!(((EventUnit() == libMDNC_gv_mMGardenTerrorSummonedBoss[libGame_gv_teamOrderIndex_C]) || (EventUnit() == libMDNC_gv_mMGardenTerrorSummonedBoss[libGame_gv_teamChaosIndex_C])))) {
            return false;
        }
    }

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

    lv_player = EventPlayer();
    lv_team = libGame_gf_TeamNumberOfPlayer(lv_player);
    if ((libGame_gf_TeamNumberIsValid(lv_team) == false)) {
        return true;
    }

    libUIUI_gf_MapMechanicsGardenOfTerrorSetUpGolemStatusBarForTeam(EventUnit(), lv_team);
    lv_enemyTeam = libGame_gf_EnemyTeam(lv_team);
    libMDNC_gv_mMGardenTerrorBossSummoned[lv_team] = false;
    libMDNC_gv_mMGardenTerrorSummonedBoss[lv_team] = null;
    libMDNC_gf_MMGardenTerrorUpdateCampHibernating();
    Wait(0.5, c_timeGame);
    libMDNC_gf_MMDragonballsTransmissionDragonActiveQ3(lv_team);
    libMDNC_gf_MMGardenTerrorGardenCooldown(lv_team);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMDNC_gt_MMGardenTerrorSummonedGolemKilled_Init () {
    libMDNC_gt_MMGardenTerrorSummonedGolemKilled = TriggerCreate("libMDNC_gt_MMGardenTerrorSummonedGolemKilled_Func");
    TriggerEnable(libMDNC_gt_MMGardenTerrorSummonedGolemKilled, false);
    TriggerAddEventUnitDied(libMDNC_gt_MMGardenTerrorSummonedGolemKilled, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMGardenTerror UI Handler
//--------------------------------------------------------------------------------------------------
bool libMDNC_gt_MMGardenTerrorUIHandler_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_indexTeam;
    int lv_indexTeamEnemy;
    int lv_state;
    int lv_lastState;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_state = libMDNC_ge_MMGardenTerrorState_Idle;
    lv_lastState = libMDNC_ge_MMGardenTerrorState_Night;

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

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

    TriggerEnable(TriggerGetCurrent(), false);
    while (true) {
        if ((libMDNC_gv_mMGardenTerrorDays == 1) && (TimerIsPaused(libMDNC_gv_mMGardenTerrorPrepTimer) == false) && (TimerGetRemaining(libMDNC_gv_mMGardenTerrorPrepTimer) > 0.0)) {
            lv_state = libMDNC_ge_MMGardenTerrorState_Preparing;
            if ((lv_state != lv_lastState)) {
                libUIUI_gf_MapMechanicsGardenOfTerrorShowHidePanel(true);
                libUIUI_gf_MapMechanicsGardenOfTerrorShowHideNightWarning(true);
            }

            libUIUI_gf_MapMechanicsGardenOfTerrorSetNightWarningTime(FixedToInt(TimerGetRemaining(libMDNC_gv_mMGardenTerrorPrepTimer)));
            lv_lastState = lv_state;
        }
        else if ((libMDNC_gv_mMGardenTerrorNightFallen == true)) {
            lv_state = libMDNC_ge_MMGardenTerrorState_Night;
            if ((lv_state != lv_lastState)) {
                libUIUI_gf_MapMechanicsGardenOfTerrorShowHideNightWarning(false);
                libUIUI_gf_MapMechanicsGardenOfTerrorSetNightWarningTime(0);
                libUIUI_gf_MapMechanicsGardenOfTerrorShowHidePanel(true);
            }

            libMDNC_gf_MMGardenTerrorUIUpdateText();
            libMDNC_gf_MMGardenTerrorUIUpdateGolemPanel();
            lv_lastState = lv_state;
        }
        else if (true) {
            lv_state = libMDNC_ge_MMGardenTerrorState_Day;
            if ((lv_state != lv_lastState)) {
                libUIUI_gf_MapMechanicsGardenOfTerrorShowHidePanel(true);
            }

            if ((TimerIsPaused(libMDNC_gv_mMGardenTerrorPrepTimer) == false) && (TimerGetRemaining(libMDNC_gv_mMGardenTerrorPrepTimer) > 0.0)) {
                libUIUI_gf_MapMechanicsGardenOfTerrorSetNightWarningTime(FixedToInt(TimerGetRemaining(libMDNC_gv_mMGardenTerrorPrepTimer)));
                libUIUI_gf_MapMechanicsGardenOfTerrorShowHideNightWarning(true);
            }

            libMDNC_gf_MMGardenTerrorUIUpdateText();
            libMDNC_gf_MMGardenTerrorUIUpdateGolemPanel();
            lv_lastState = lv_state;
        }
        TriggerExecute(libMDNC_gt_MMGardenTerrorUIUpdateSummonedBossBar, true, false);
        Wait(1.0, c_timeGame);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMDNC_gt_MMGardenTerrorUIHandler_Init () {
    libMDNC_gt_MMGardenTerrorUIHandler = TriggerCreate("libMDNC_gt_MMGardenTerrorUIHandler_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMGardenTerror UI Update Summoned Boss Bar
//--------------------------------------------------------------------------------------------------
bool libMDNC_gt_MMGardenTerrorUIUpdateSummonedBossBar_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_itTeam;

    // Automatic Variable Declarations
    const int auto4DD548A7_ae = libCore_gv_bALMaxTeams;
    const int auto4DD548A7_ai = 1;

    // Variable Initialization

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

    lv_itTeam = 1;
    for ( ; ( (auto4DD548A7_ai >= 0 && lv_itTeam <= auto4DD548A7_ae) || (auto4DD548A7_ai < 0 && lv_itTeam >= auto4DD548A7_ae) ) ; lv_itTeam += auto4DD548A7_ai ) {
        if (((libMDNC_gv_mMGardenTerrorGarden[lv_itTeam].lv_growing == true) || (libMDNC_gv_mMGardenTerrorGarden[lv_itTeam].lv_readyToControl == true))) {
            continue;
        }

        if ((UnitIsAlive(libMDNC_gv_mMGardenTerrorSummonedBoss[lv_itTeam]) == true)) {
            libUIUI_gf_MapMechanicsGardenOfTerrorSetUpGolemStatusBarForTeam(libMDNC_gv_mMGardenTerrorSummonedBoss[lv_itTeam], lv_itTeam);
        }

        if ((UnitIsAlive(libMDNC_gv_mMGardenTerrorSummonedBoss[lv_itTeam]) == true)) {
            libUIUI_gf_MapMechanicsGardenOfTerrorSetGolemRemainingTimeForTeam(lv_itTeam, FixedToInt(UnitBehaviorDuration(libMDNC_gv_mMGardenTerrorSummonedBoss[lv_itTeam], "PlantHorrorTimedLife")));
        }
        else {
            libUIUI_gf_MapMechanicsGardenOfTerrorSetGolemRemainingTimeForTeam(lv_itTeam, 0);
        }
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMDNC_gt_MMGardenTerrorUIUpdateSummonedBossBar_Init () {
    libMDNC_gt_MMGardenTerrorUIUpdateSummonedBossBar = TriggerCreate("libMDNC_gt_MMGardenTerrorUIUpdateSummonedBossBar_Func");
}

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

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

    TriggerEnable(TriggerGetCurrent(), false);
    libMDNC_gv_mMGardenTerrorDebugAlways = 1;
    TriggerDebugOutput(1, StringExternal("Param/Value/lib_MDNC_1C623E7E"), true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMDNC_gt_MMGardenTerrorDisableEvent_Init () {
    libMDNC_gt_MMGardenTerrorDisableEvent = TriggerCreate("libMDNC_gt_MMGardenTerrorDisableEvent_Func");
    TriggerAddEventChatMessage(libMDNC_gt_MMGardenTerrorDisableEvent, c_playerAny, "DisableEvent", true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMGardenTerror Debug - Temp
//--------------------------------------------------------------------------------------------------
bool libMDNC_gt_MMGardenTerrorDebugTemp_Func (bool testConds, bool runActions) {
    // Variable Declarations
    point lv_loc;

    // Automatic Variable Declarations
    // Variable Initialization

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

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

    TriggerDebugOutput(1, FixedToText(PointGetFacing(libMDNC_gv_mMGardenTerrorGarden[1].lv_positions), c_fixedPrecisionAny), true);
    lv_loc = libMDNC_gv_mMGardenTerrorGarden[1].lv_positions;
    TriggerDebugOutput(1, libCore_gf_ConvertPointToText(lv_loc), true);
    lv_loc = PointWithOffsetPolar(lv_loc, 2.0, PointGetFacing(lv_loc));
    TriggerDebugOutput(1, libCore_gf_ConvertPointToText(lv_loc), true);
    UnitSetPosition(libMDNC_gv_mMGardenTerrorSummonedBoss[1], lv_loc, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMDNC_gt_MMGardenTerrorDebugTemp_Init () {
    libMDNC_gt_MMGardenTerrorDebugTemp = TriggerCreate("libMDNC_gt_MMGardenTerrorDebugTemp_Func");
    TriggerEnable(libMDNC_gt_MMGardenTerrorDebugTemp, false);
    TriggerAddEventChatMessage(libMDNC_gt_MMGardenTerrorDebugTemp, c_playerAny, "-ht", false);
}

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

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

    TimerPause(libMDNC_gv_mMGardenTerrorPrepTimer, true);
    libMDNC_gf_MMGardenTerrorNightPrepare();
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMDNC_gt_MMGardenTerrorDebugStart1_Init () {
    libMDNC_gt_MMGardenTerrorDebugStart1 = TriggerCreate("libMDNC_gt_MMGardenTerrorDebugStart1_Func");
    TriggerEnable(libMDNC_gt_MMGardenTerrorDebugStart1, false);
    TriggerAddEventChatMessage(libMDNC_gt_MMGardenTerrorDebugStart1, c_playerAny, "EVENTSTART", true);
}

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

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

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

    TimerPause(libMDNC_gv_mMGardenTerrorPrepTimer, true);
    libMDNC_gf_MMGardenTerrorNightPrepare();
    TimerStart(libMDNC_gv_mMGardenTerrorPrepTimer, 1.0, false, c_timeGame);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMDNC_gt_MMGardenTerrorDebugStart_Init () {
    libMDNC_gt_MMGardenTerrorDebugStart = TriggerCreate("libMDNC_gt_MMGardenTerrorDebugStart_Func");
    TriggerEnable(libMDNC_gt_MMGardenTerrorDebugStart, false);
    TriggerAddEventChatMessage(libMDNC_gt_MMGardenTerrorDebugStart, c_playerAny, "NIGHTBEGINS", true);
    TriggerAddEventChatMessage(libMDNC_gt_MMGardenTerrorDebugStart, c_playerAny, "-NB", true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: MMGardenTerror Debug Night Ends
//--------------------------------------------------------------------------------------------------
bool libMDNC_gt_MMGardenTerrorDebugNightEnds_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_team;
    int lv_itGroup;
    unit lv_itHorror;

    // Automatic Variable Declarations
    unitgroup auto95DCE726_g;
    int auto95DCE726_u;

    // Variable Initialization

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

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

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

    lv_team = libGame_gf_TeamNumberOfPlayer(EventPlayer());
    if (((lv_team < 1) || (lv_team > 2))) {
        lv_team = 1;
    }

    libMDNC_gv_mMGardenTerrorSeedsCollected[lv_team] = StringToInt(StringWord(EventChatMessage(false), 2));
    libMDNC_gv_mMGardenTerrorSeedsCollected[libGame_gf_EnemyTeam(lv_team)] = StringToInt(StringWord(EventChatMessage(false), 3));
    auto95DCE726_g = libMDNC_gv_mMGardenTerrorNightMonsters;
    auto95DCE726_u = UnitGroupCount(auto95DCE726_g, c_unitCountAll);
    for (;; auto95DCE726_u -= 1) {
        lv_itHorror = UnitGroupUnitFromEnd(auto95DCE726_g, auto95DCE726_u);
        if (lv_itHorror == null) { break; }
        PlayerCreateEffectUnit(libCore_gv_cOMPUTER_Hostile, "Kill", lv_itHorror);
    }
    libMDNC_gv_mMGardenTerrorNightMonstersTotalCount = 0;
    libMDNC_gf_MMGardenTerrorUpdateHauntedGarden(1);
    libMDNC_gf_MMGardenTerrorUpdateHauntedGarden(2);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMDNC_gt_MMGardenTerrorDebugNightEnds_Init () {
    libMDNC_gt_MMGardenTerrorDebugNightEnds = TriggerCreate("libMDNC_gt_MMGardenTerrorDebugNightEnds_Func");
    TriggerEnable(libMDNC_gt_MMGardenTerrorDebugNightEnds, false);
    TriggerAddEventChatMessage(libMDNC_gt_MMGardenTerrorDebugNightEnds, c_playerAny, "NIGHTENDS", false);
    TriggerAddEventChatMessage(libMDNC_gt_MMGardenTerrorDebugNightEnds, c_playerAny, "-NE", false);
}

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

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

    libMDNC_gv_mMGardenTerrorDebugAlways = 1;
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMDNC_gt_MMGardenTerrorDebugAlwaysDay_Init () {
    libMDNC_gt_MMGardenTerrorDebugAlwaysDay = TriggerCreate("libMDNC_gt_MMGardenTerrorDebugAlwaysDay_Func");
    TriggerEnable(libMDNC_gt_MMGardenTerrorDebugAlwaysDay, false);
    TriggerAddEventChatMessage(libMDNC_gt_MMGardenTerrorDebugAlwaysDay, c_playerAny, "ALWAYSDAY", true);
}

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

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

    libMDNC_gv_mMGardenTerrorDebugAlways = 2;
    if ((libMDNC_gv_mMGardenTerrorNightFallen == true)) {
        return true;
    }

    libMDNC_gf_MMGardenTerrorNightStarts();
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMDNC_gt_MMGardenTerrorDebugAlwaysNight_Init () {
    libMDNC_gt_MMGardenTerrorDebugAlwaysNight = TriggerCreate("libMDNC_gt_MMGardenTerrorDebugAlwaysNight_Func");
    TriggerEnable(libMDNC_gt_MMGardenTerrorDebugAlwaysNight, false);
    TriggerAddEventChatMessage(libMDNC_gt_MMGardenTerrorDebugAlwaysNight, c_playerAny, "ALWAYSNIGHT", true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Plant Horror Overgrowth Apply XP
//--------------------------------------------------------------------------------------------------
bool libMDNC_gt_PlantHorrorOvergrowthApplyXP_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((UnitGetType(EventUnit()) == "PlantHorrorOvergrowthPlant"))) {
            return false;
        }
    }

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

    UnitXPAddXP(EventUnit(), null, FixedToInt(libGame_gv_scalingTicks));
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMDNC_gt_PlantHorrorOvergrowthApplyXP_Init () {
    libMDNC_gt_PlantHorrorOvergrowthApplyXP = TriggerCreate("libMDNC_gt_PlantHorrorOvergrowthApplyXP_Func");
    TriggerAddEventUnitRegion(libMDNC_gt_PlantHorrorOvergrowthApplyXP, null, RegionEntireMap(), true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Plant Horror Overgrowth Plant Scaling
//--------------------------------------------------------------------------------------------------
bool libMDNC_gt_PlantHorrorOvergrowthPlantScaling_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_itPlayer;
    string lv_amount;
    int lv_newAmount;

    // Automatic Variable Declarations
    int auto6BA63E15_ae;

    // Variable Initialization
    lv_amount = "";

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

    libMDNC_gv_plantHorrorOvergrowthPlantScaling += 1;
    if ((libMDNC_gv_plantHorrorOvergrowthPlantScaling >= 3)) {
        lv_amount = CatalogFieldValueGet(c_gameCatalogEffect, "PlantHorrorOvergrowthTooltipDummyDamage", "Amount", 1);
        lv_newAmount = (StringToInt(lv_amount) + 7);
        auto6BA63E15_ae = 10;
        lv_itPlayer = 1;
        for ( ; lv_itPlayer <= auto6BA63E15_ae ; lv_itPlayer += 1 ) {
            CatalogFieldValueSet(c_gameCatalogEffect, "PlantHorrorOvergrowthTooltipDummyDamage", "Amount", lv_itPlayer, IntToString(lv_newAmount));
            CatalogFieldValueSet(c_gameCatalogEffect, "PlantHorrorOvergrowthSelfDamage", "Amount", lv_itPlayer, IntToString(FixedToInt((CatalogFieldValueGetAsInt(c_gameCatalogEffect, "PlantHorrorOvergrowthSelfDamage", "Amount", lv_itPlayer) + libMDNC_gv_mMGardenTerrorOvergrowthSelfHealthDecay_C))));
        }
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libMDNC_gt_PlantHorrorOvergrowthPlantScaling_Init () {
    libMDNC_gt_PlantHorrorOvergrowthPlantScaling = TriggerCreate("libMDNC_gt_PlantHorrorOvergrowthPlantScaling_Func");
    TriggerAddEventTimer(libMDNC_gt_PlantHorrorOvergrowthPlantScaling, libGame_gv_scalingTimer);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Night Minion Becomes Idle During Day
//--------------------------------------------------------------------------------------------------
bool libMDNC_gt_NightMinionBecomesIdleDuringDay_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((UnitGroupHasUnit(libMDNC_gv_nightMinionActiveGroup, EventUnit()) == true))) {
            return false;
        }
    }

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

    UnitRemove(EventUnit());
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMDNC_gt_NightMinionBecomesIdleDuringDay_Init () {
    libMDNC_gt_NightMinionBecomesIdleDuringDay = TriggerCreate("libMDNC_gt_NightMinionBecomesIdleDuringDay_Func");
    TriggerAddEventUnitBecomesIdle(libMDNC_gt_NightMinionBecomesIdleDuringDay, null, true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Lignify Hero
//--------------------------------------------------------------------------------------------------
bool libMDNC_gt_LignifyHero_Func (bool testConds, bool runActions) {
    // Variable Declarations
    fixed lv_earnedXP;
    fixed lv_wait;
    int lv_player;
    string lv_weapon;

    // Automatic Variable Declarations
    // Variable Initialization

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

    lv_earnedXP = UnitGetPropertyFixed(EventUnit(), c_unitPropXP, c_unitPropCurrent);
    lv_player = UnitGetOwner(EventUnit());
    lv_weapon = UnitWeaponGet(EventUnit(), 1);
    UnitXPAddXP(EventUnit(), "LignifyScaling", lv_earnedXP);
    UnitSetPropertyFixed(EventUnit(), c_unitPropHeight, 0.0);
    libUIUI_gf_HeroConsoleUnitStatusBarsUpdateStunDeathBar(EventUnitBehavior(), lv_player);
    lv_wait = UnitBehaviorDuration(EventUnit(), EventUnitBehavior());
    Wait(lv_wait, c_timeGame);
    libGDHL_gf_RestoreHeight(EventUnit());
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMDNC_gt_LignifyHero_Init () {
    libMDNC_gt_LignifyHero = TriggerCreate("libMDNC_gt_LignifyHero_Func");
    TriggerAddEventUnitBehaviorChange(libMDNC_gt_LignifyHero, null, "PlantHorrorPolymorph", c_unitBehaviorChangeActivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Lignify Hero Off
//--------------------------------------------------------------------------------------------------
bool libMDNC_gt_LignifyHeroOff_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_player;

    // Automatic Variable Declarations
    // Variable Initialization

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

    lv_player = UnitGetOwner(EventUnit());
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMDNC_gt_LignifyHeroOff_Init () {
    libMDNC_gt_LignifyHeroOff = TriggerCreate("libMDNC_gt_LignifyHeroOff_Func");
    TriggerAddEventUnitBehaviorChange(libMDNC_gt_LignifyHeroOff, null, "PlantHorrorPolymorph", c_unitBehaviorChangeDeactivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Vehicle Plant Horror Vine Shield Damage Response
//--------------------------------------------------------------------------------------------------
bool libMDNC_gt_VehiclePlantHorrorVineShieldDamageResponse_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_tyrael;
    fixed lv_damage;
    unit lv_attacker;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_attacker = EventUnitDamageSourceUnit();

    // Conditions
    if (testConds) {
        if (!((UnitHasBehavior(EventUnit(), "VehiclePlantHorrorVineShieldTarget") == true))) {
            return false;
        }
    }

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

    lv_tyrael = UnitBehaviorEffectUnit(EventUnit(), "VehiclePlantHorrorVineShieldTarget", c_effectUnitCaster, 0);
    lv_damage = EventUnitDamageBehaviorShield();
    if ((lv_damage >= UnitGetPropertyFixed(lv_tyrael, c_unitPropLife, c_unitPropCurrent))) {
        lv_damage = (UnitGetPropertyFixed(lv_tyrael, c_unitPropLife, c_unitPropCurrent) - 1.0);
        UnitBehaviorRemove(lv_tyrael, "VehiclePlantHorrorVineShieldCaster", 1);
    }

    UnitDamage(lv_attacker, "VehiclePlantHorrorVineShieldRedirectDamage", lv_tyrael, lv_damage);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMDNC_gt_VehiclePlantHorrorVineShieldDamageResponse_Init () {
    libMDNC_gt_VehiclePlantHorrorVineShieldDamageResponse = TriggerCreate("libMDNC_gt_VehiclePlantHorrorVineShieldDamageResponse_Func");
    TriggerEnable(libMDNC_gt_VehiclePlantHorrorVineShieldDamageResponse, false);
    TriggerAddEventUnitDamaged(libMDNC_gt_VehiclePlantHorrorVineShieldDamageResponse, null, c_unitDamageTypeAny, c_unitDamageNonFatal, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Vehicle Plant Horror Vine Shield Increment
//--------------------------------------------------------------------------------------------------
bool libMDNC_gt_VehiclePlantHorrorVineShieldIncrement_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libMDNC_gv_vehiclePlantHorrorVineShieldBuffCount += 1;
    if ((libMDNC_gv_vehiclePlantHorrorVineShieldBuffCount >= 1)) {
        TriggerEnable(libMDNC_gt_VehiclePlantHorrorVineShieldDamageResponse, true);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libMDNC_gt_VehiclePlantHorrorVineShieldIncrement_Init () {
    libMDNC_gt_VehiclePlantHorrorVineShieldIncrement = TriggerCreate("libMDNC_gt_VehiclePlantHorrorVineShieldIncrement_Func");
    TriggerAddEventUnitBehaviorChange(libMDNC_gt_VehiclePlantHorrorVineShieldIncrement, null, "VehiclePlantHorrorVineShieldTarget", c_unitBehaviorChangeActivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Vehicle Plant Horror Vine Shield Decrement
//--------------------------------------------------------------------------------------------------
bool libMDNC_gt_VehiclePlantHorrorVineShieldDecrement_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libMDNC_gv_vehiclePlantHorrorVineShieldBuffCount -= 1;
    if ((libMDNC_gv_vehiclePlantHorrorVineShieldBuffCount < 1)) {
        TriggerEnable(libMDNC_gt_VehiclePlantHorrorVineShieldDamageResponse, false);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libMDNC_gt_VehiclePlantHorrorVineShieldDecrement_Init () {
    libMDNC_gt_VehiclePlantHorrorVineShieldDecrement = TriggerCreate("libMDNC_gt_VehiclePlantHorrorVineShieldDecrement_Func");
    TriggerAddEventUnitBehaviorChange(libMDNC_gt_VehiclePlantHorrorVineShieldDecrement, null, "VehiclePlantHorrorVineShieldTarget", c_unitBehaviorChangeDeactivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Vehicle Plant Horror Vine Grab Activate
//--------------------------------------------------------------------------------------------------
bool libMDNC_gt_VehiclePlantHorrorVineGrabActivate_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_eatenUnit;
    unit lv_plantHorror;
    actor lv_eatenUnitActor;

    // Automatic Variable Declarations
    // Variable Initialization

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

    lv_plantHorror = UnitBehaviorEffectUnit(EventUnit(), "PlantHorrorVineGrabTargetEaten", c_effectUnitCaster, 0);
    lv_eatenUnit = UnitBehaviorEffectUnit(EventUnit(), "PlantHorrorVineGrabTargetEaten", c_effectUnitTarget, 0);
    libNtve_gf_AttachModelToUnit(lv_plantHorror, libCore_gf_GetModelLinkForUnitType(UnitGetType(lv_eatenUnit)), "Ref_Hand Right");
    lv_eatenUnitActor = libNtve_gf_ActorLastCreated();
    ActorSend(lv_eatenUnitActor, "AnimPlay Flail Flail PlayForever");
    while ((UnitIsAlive(lv_plantHorror) == true) && (UnitHasBehavior2(lv_eatenUnit, "PlantHorrorVineGrabTargetEaten") == true)) {
        if ((UnitHasBehavior2(lv_eatenUnit, "PlantHorrorVineGrabTargetEaten") == true)) {
            if ((DistanceBetweenPoints(UnitGetPosition(lv_plantHorror), UnitGetPosition(lv_eatenUnit)) >= 4.0)) {
                UnitSetPosition(lv_eatenUnit, UnitGetPosition(lv_plantHorror), false);
            }
            else {
                UnitSetPosition(lv_eatenUnit, UnitGetPosition(lv_plantHorror), true);
            }
            Wait(0.0625, c_timeGame);
        }

        UnitSetPosition(lv_eatenUnit, PointWithOffsetPolar(UnitGetPosition(lv_plantHorror), 1.0, UnitGetFacing(lv_plantHorror)), false);
    }
    ActorSend(lv_eatenUnitActor, "Destroy Immediate");
    return true;
}

//--------------------------------------------------------------------------------------------------
void libMDNC_gt_VehiclePlantHorrorVineGrabActivate_Init () {
    libMDNC_gt_VehiclePlantHorrorVineGrabActivate = TriggerCreate("libMDNC_gt_VehiclePlantHorrorVineGrabActivate_Func");
    TriggerAddEventUnitBehaviorChange(libMDNC_gt_VehiclePlantHorrorVineGrabActivate, null, "PlantHorrorVineGrabTargetEaten", c_unitBehaviorChangeActivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Jungle Plant Horror Defender Spells
//--------------------------------------------------------------------------------------------------
bool libMDNC_gt_JunglePlantHorrorDefenderSpells_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_creepUnit;
    int lv_defenderAIIndex;
    unit lv_currentOrderTarget;
    int lv_graveGolemBindingRootsValidTargets;
    unitgroup lv_enemyGroup;

    // Automatic Variable Declarations
    unitgroup auto0BC9AC6E_g;
    int auto0BC9AC6E_u;
    unit auto0BC9AC6E_var;

    // Variable Initialization
    lv_creepUnit = libCore_gv_segTriggerUnit;
    lv_defenderAIIndex = libCore_gv_segTriggerIndex;
    lv_enemyGroup = UnitGroupEmpty();

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

    if ((libAIAI_gf_DefendersAreFighting(lv_defenderAIIndex) == true) && ((libAIAI_gv_defenderAI[lv_defenderAIIndex].lv_fightStartTime + libAIAI_gv_aIDefenderMinTimeBeforeCasting) < TimerGetElapsed(libGame_gv_gameTimer))) {
        if ((UnitGetCooldown(lv_creepUnit, "Abil/PlantHorrorPoisonBulbs") <= 0.0) && (UnitGroupCount(UnitGroup(null, c_playerAny, RegionCircle(UnitGetPosition(lv_creepUnit), 5.0), UnitFilter((1 << c_targetFilterHeroic) | (1 << c_targetFilterVisible), 0, (1 << c_targetFilterPlayer) | (1 << c_targetFilterAlly) | (1 << c_targetFilterStructure) | (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0), c_unitCountAlive) > 1)) {
            UnitIssueOrder(lv_creepUnit, Order(AbilityCommand("UnderworldBossStun", 0)), c_orderQueueReplace);
            libAIAI_gv_defenderAICreepNeedsNewOrder = false;
        }
        else {
            lv_enemyGroup = libNtve_gf_UnitsInRegionWithAllianceToPlayerMatchingCondition(null, "", "", UnitGetOwner(lv_creepUnit), c_unitAllianceEnemy, RegionCircle(UnitGetPosition(lv_creepUnit), 8.0), UnitFilter((1 << c_targetFilterHeroic) | (1 << c_targetFilterVisible), 0, (1 << c_targetFilterPlayer) | (1 << c_targetFilterAlly) | (1 << c_targetFilterStructure) | (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
            if ((UnitGetCooldown(lv_creepUnit, "Abil/UnderworldBossRoots") <= 0.0) && (UnitGroupCount(lv_enemyGroup, c_unitCountAlive) > 1)) {
                auto0BC9AC6E_g = lv_enemyGroup;
                auto0BC9AC6E_u = UnitGroupCount(auto0BC9AC6E_g, c_unitCountAll);
                for (;; auto0BC9AC6E_u -= 1) {
                    auto0BC9AC6E_var = UnitGroupUnitFromEnd(auto0BC9AC6E_g, auto0BC9AC6E_u);
                    if (auto0BC9AC6E_var == null) { break; }
                    if ((auto0BC9AC6E_var != lv_currentOrderTarget) && (DistanceBetweenPoints(UnitGetPosition(auto0BC9AC6E_var), UnitGetPosition(lv_creepUnit)) >= 2.0)) {
                        lv_graveGolemBindingRootsValidTargets += 1;
                    }

                }
                if ((lv_graveGolemBindingRootsValidTargets >= 1)) {
                    UnitIssueOrder(lv_creepUnit, OrderTargetingPoint(AbilityCommand("UnderworldBossRoots", 0), UnitGetPosition(libMapM_gf_JungleGetRandomEnemyHeroInRangeOfMinionWithMinimumRangeRequirements(lv_creepUnit, UnitGetPosition(lv_creepUnit), 0.0, 8.0, lv_currentOrderTarget))), c_orderQueueReplace);
                    UnitAddCooldown(lv_creepUnit, "Abil/UnderworldBossRoots", 1.5);
                    libAIAI_gv_defenderAICreepNeedsNewOrder = false;
                }
                else {
                    UnitAddCooldown(lv_creepUnit, "Abil/UnderworldBossRoots", 0.5);
                }
            }

        }
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libMDNC_gt_JunglePlantHorrorDefenderSpells_Init () {
    libMDNC_gt_JunglePlantHorrorDefenderSpells = TriggerCreate("libMDNC_gt_JunglePlantHorrorDefenderSpells_Func");
}

void libMDNC_InitTriggers () {
    libMDNC_gt_MMGardenTerrorInit_Init();
    libMDNC_gt_MMGardenTerrorPingDataInit_Init();
    libMDNC_gt_MMGardenTerrorAnnouncerInit_Init();
    libMDNC_gt_MMGardenTerrorGatesOpened_Init();
    libMDNC_gt_MMGardenTerrorNightStarts_Init();
    libMDNC_gt_MMGardenTerrorNightStartLightTransition_Init();
    libMDNC_gt_MMGardenTerrorNightEndLightTransition_Init();
    libMDNC_gt_MMGardenTerrorNightMonsterDies_Init();
    libMDNC_gt_MMGardenTerrorSeedDropped_Init();
    libMDNC_gt_MMGardenTerrorSeedPickup_Init();
    libMDNC_gt_MMGardenTerrorNightVignette_Init();
    libMDNC_gt_MMGardenTerrorPlantDamageCalculation_Init();
    libMDNC_gt_MMGardenTerrorPlantDamageReport_Init();
    libMDNC_gt_MMGardenTerrorChannelStarted_Init();
    libMDNC_gt_MMGardenTerrorChannelCompleted_Init();
    libMDNC_gt_MMGardenTerrorGolemSummonStarted_Init();
    libMDNC_gt_MMGardenTerrorGolemSummoned_Init();
    libMDNC_gt_MMGardenTerrorSummonedGolemKilled_Init();
    libMDNC_gt_MMGardenTerrorUIHandler_Init();
    libMDNC_gt_MMGardenTerrorUIUpdateSummonedBossBar_Init();
    libMDNC_gt_MMGardenTerrorDisableEvent_Init();
    libMDNC_gt_MMGardenTerrorDebugTemp_Init();
    libMDNC_gt_MMGardenTerrorDebugStart1_Init();
    libMDNC_gt_MMGardenTerrorDebugStart_Init();
    libMDNC_gt_MMGardenTerrorDebugNightEnds_Init();
    libMDNC_gt_MMGardenTerrorDebugAlwaysDay_Init();
    libMDNC_gt_MMGardenTerrorDebugAlwaysNight_Init();
    libMDNC_gt_PlantHorrorOvergrowthApplyXP_Init();
    libMDNC_gt_PlantHorrorOvergrowthPlantScaling_Init();
    libMDNC_gt_NightMinionBecomesIdleDuringDay_Init();
    libMDNC_gt_LignifyHero_Init();
    libMDNC_gt_LignifyHeroOff_Init();
    libMDNC_gt_VehiclePlantHorrorVineShieldDamageResponse_Init();
    libMDNC_gt_VehiclePlantHorrorVineShieldIncrement_Init();
    libMDNC_gt_VehiclePlantHorrorVineShieldDecrement_Init();
    libMDNC_gt_VehiclePlantHorrorVineGrabActivate_Init();
    libMDNC_gt_JunglePlantHorrorDefenderSpells_Init();
}

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

void libMDNC_InitLib () {
    if (libMDNC_InitLib_completed) {
        return;
    }

    libMDNC_InitLib_completed = true;

    libMDNC_InitLibraries();
    libMDNC_InitVariables();
    libMDNC_InitTriggers();
}