include "TriggerLibs/NativeLib"

include "TriggerLibs/HeroesLib"

include "TriggerLibs/GameLib"

include "TriggerLibs/MapMechanicsLib"

include "TriggerLibs/AILib"

include "TriggerLibs/UILib"



include "LibOVER_h"



//--------------------------------------------------------------------------------------------------

// Library: Overwatch Data

//--------------------------------------------------------------------------------------------------

// External Library Initialization

void libOVER_InitLibraries () {

    libNtve_InitVariables();

    libCore_InitVariables();

    libGame_InitVariables();

    libMapM_InitVariables();

    libAIAI_InitVariables();

    libUIUI_InitVariables();

}



// Variable Initialization

bool libOVER_InitVariables_completed = false;



void libOVER_InitVariables () {

    if (libOVER_InitVariables_completed) {

        return;

    }



    libOVER_InitVariables_completed = true;



    libOVER_gv_itemsOnGround = UnitGroupEmpty();

    libOVER_gv_overwatchModExtraScalingEnabled = true;

    libOVER_gv_data_XP_TrioGroupCampCapture = 345.0;

    libOVER_gv_data_XP_IndividualCampCapture = 625.0;

    libOVER_gv_data_XP_TurretCampCapture = 460.0;

}



// Functions

void libOVER_gf_HeroPicksUpItem (unit lp_unit, unit lp_pickUpItem, point lp_dropPoint) {

    // Variable Declarations

    unit lv_pickupUnit;

    int lv_textTag;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_textTag = c_textTagNone;



    // Implementation

    UnitGroupRemove(libOVER_gv_itemsOnGround, lp_pickUpItem);

    RemoveUnitOfInterest(lp_pickUpItem, "PickupOverwatchItem", libNtve_ge_GoalTeam_Both);

    TextTagDestroy(libCore_gf_TextTagStoredForUnit(lp_pickUpItem, 1));

    UnitKill(lp_pickUpItem);

    if ((UnitHasBehavior2(lp_unit, "HasMapMechanicInstantAbility2") == true)) {

        UnitBehaviorRemove(lp_unit, "HasMapMechanicInstantAbility", c_unitBehaviorCountAll);

        UnitBehaviorRemove(lp_unit, "HasMapMechanicInstantAbility2", c_unitBehaviorCountAll);

        libNtve_gf_CreateUnitsWithDefaultFacing(1, "DragonSpiritsPickup", c_unitCreateIgnorePlacement, libCore_gv_cOMPUTER_Neutral, lp_dropPoint, null);

        TextTagCreate(StringExternal("Param/Value/lib_OVER_A7B7F96E"), 24, lp_dropPoint, 3.0, false, false, PlayerGroupAll());

    }

    else if ((UnitHasBehavior2(lp_unit, "HasMapMechanicTargetAbility") == true)) {

        UnitBehaviorRemove(lp_unit, "HasMapMechanicTargetAbility", 1);

        libNtve_gf_CreateUnitsWithDefaultFacing(1, "TurretPickup", c_unitCreateIgnorePlacement, libCore_gv_cOMPUTER_Neutral, lp_dropPoint, null);

        TextTagCreate(StringExternal("Param/Value/lib_OVER_EE97DF36"), 24, lp_dropPoint, 3.0, false, false, PlayerGroupAll());

    }

    else if ((UnitHasBehavior2(lp_unit, "HasMapMechanicTargetAbility2") == true)) {

        UnitBehaviorRemove(lp_unit, "HasMapMechanicTargetAbility2", 1);

        libNtve_gf_CreateUnitsWithDefaultFacing(1, "HealingPulsePickup", c_unitCreateIgnorePlacement, libCore_gv_cOMPUTER_Neutral, lp_dropPoint, null);

        TextTagCreate(StringExternal("Param/Value/lib_OVER_1F5EA6C2"), 24, lp_dropPoint, 3.0, false, false, PlayerGroupAll());

    }

    else if (true) {

        return ;

    }

    lv_pickupUnit = UnitLastCreated();

    lv_textTag = TextTagLastCreated();

    UnitGroupAdd(libOVER_gv_itemsOnGround, lv_pickupUnit);

    AddUnitOfInterest(lv_pickupUnit, 0.0, 0.0, "PickupOverwatchItem", libNtve_ge_GoalTeam_Both, 0);

    libCore_gf_StoreTextTagForUnit(lv_pickupUnit, 1, lv_textTag);

    TextTagAttachToUnit(lv_textTag, lv_pickupUnit, 3.0);

    libOVER_gf_ShareVisionofItemPickup(lv_pickupUnit);

}



void libOVER_gf_HeroDiesWithItem (string lp_itemType, point lp_dropPoint, text lp_itemText) {

    // Variable Declarations

    unit lv_pickupUnit;

    int lv_textTag;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_textTag = c_textTagNone;



    // Implementation

    libNtve_gf_CreateUnitsWithDefaultFacing(1, lp_itemType, 0, libCore_gv_cOMPUTER_Neutral, lp_dropPoint, null);

    lv_pickupUnit = UnitLastCreated();

    UnitGroupAdd(libOVER_gv_itemsOnGround, lv_pickupUnit);

    AddUnitOfInterest(lv_pickupUnit, 0.0, 0.0, "PickupOverwatchItem", libNtve_ge_GoalTeam_Both, 0);

    TextExpressionSetToken("Param/Expression/lib_OVER_F1896F11", "A", lp_itemText);

    TextTagCreate(TextExpressionAssemble("Param/Expression/lib_OVER_F1896F11"), 24, UnitGetPosition(lv_pickupUnit), 3.0, false, false, PlayerGroupAll());

    lv_textTag = TextTagLastCreated();

    libCore_gf_StoreTextTagForUnit(lv_pickupUnit, 1, lv_textTag);

    TextTagAttachToUnit(lv_textTag, lv_pickupUnit, 3.0);

    libOVER_gf_ShareVisionofItemPickup(lv_pickupUnit);

}



trigger auto_libOVER_gf_ShareVisionofItemPickup_Trigger = null;

unit auto_libOVER_gf_ShareVisionofItemPickup_lp_pickupUnit;



void libOVER_gf_ShareVisionofItemPickup (unit lp_pickupUnit) {

    auto_libOVER_gf_ShareVisionofItemPickup_lp_pickupUnit = lp_pickupUnit;



    if (auto_libOVER_gf_ShareVisionofItemPickup_Trigger == null) {

        auto_libOVER_gf_ShareVisionofItemPickup_Trigger = TriggerCreate("auto_libOVER_gf_ShareVisionofItemPickup_TriggerFunc");

    }



    TriggerExecute(auto_libOVER_gf_ShareVisionofItemPickup_Trigger, false, false);

}



bool auto_libOVER_gf_ShareVisionofItemPickup_TriggerFunc (bool testConds, bool runActions) {

    unit lp_pickupUnit = auto_libOVER_gf_ShareVisionofItemPickup_lp_pickupUnit;



    // Variable Declarations

    timer lv_visionTimer;

    int lv_team;

    int lv_player;

    bool[libCore_gv_bALMaxTeams + 1] lv_visionShared;



    // Automatic Variable Declarations

    const int autoB6ACF539_ae = libGame_gv_teamChaosIndex_C;

    const int autoB6ACF539_ai = 1;

    const int autoBF2C8976_ae = libGame_gv_teamChaosIndex_C;

    const int autoBF2C8976_ai = 1;



    // Variable Initialization

    lv_visionTimer = TimerCreate();



    // Implementation

    TimerStart(lv_visionTimer, 5.0, false, c_timeGame);

    while ((TimerGetRemaining(lv_visionTimer) > 0.0)) {

        if ((UnitIsAlive(lp_pickupUnit) == true)) {

            lv_team = libGame_gv_teamOrderIndex_C;

            for ( ; ( (autoB6ACF539_ai >= 0 && lv_team <= autoB6ACF539_ae) || (autoB6ACF539_ai < 0 && lv_team >= autoB6ACF539_ae) ) ; lv_team += autoB6ACF539_ai ) {

                lv_player = libGame_gf_ComputerPlayerInTeam(lv_team);

                if ((libNtve_gf_UnitIsVisibleToPlayer(lp_pickupUnit, lv_player) == true) && (lv_visionShared[lv_team] == false)) {

                    lv_visionShared[lv_team] = true;

                    libNtve_gf_ShareVisionofUnit(lp_pickupUnit, true, lv_player);

                    TextTagShow(libCore_gf_TextTagStoredForUnit(lp_pickupUnit, 1), libGame_gf_PlayersOnTeamHeroes(lv_team, false), true);

                }



            }

        }

        else {

            return true;

        }

        Wait(0.0625, c_timeGame);

    }

    lv_team = libGame_gv_teamOrderIndex_C;

    for ( ; ( (autoBF2C8976_ai >= 0 && lv_team <= autoBF2C8976_ae) || (autoBF2C8976_ai < 0 && lv_team >= autoBF2C8976_ae) ) ; lv_team += autoBF2C8976_ai ) {

        if ((UnitIsAlive(lp_pickupUnit) == true) && (lv_visionShared[lv_team] == false)) {

            libNtve_gf_ShareVisionofUnit(lp_pickupUnit, true, libGame_gf_ComputerPlayerInTeam(lv_team));

            TextTagShow(libCore_gf_TextTagStoredForUnit(lp_pickupUnit, 1), libGame_gf_PlayersOnTeamHeroes(libGame_gf_TeamNumberOfPlayer(lv_team), false), true);

        }



    }

    return true;

}



void libOVER_gf_InitBossMercCampBossCamp1 () {

    // Variable Declarations

    int lv_campType;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_campType = (libMapM_ge_JungleCampDefenderTypes_BossCamp1);



    // Implementation

    TriggerEnable(libOVER_gt_BossEatsPlayer, true);

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_campTypeMinimapLabel = StringExternal("Param/Value/lib_OVER_33B3B4E4");

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_customTextTagInfoText = StringExternal("Param/Value/lib_OVER_257B3D59");

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_campIsSoloable = false;

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_defendersCoweronDeath = false;

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_initialSpawnDelay = libMapM_gv_genericMercBossCampInitialSpawnDelay_C;

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_respawnTime = 300.0;

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_numberOfCreeps = 1;

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_creepUnitTypes[1] = "JungleGraveGolemDefender";

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_xPAwardForCapture = libOVER_gv_data_XP_BossCampCapture;

    libMapM_gv_dataJungleCampMercData[lv_campType].lv_numberOfMinionsSpawned = 0;

    libMapM_gf_DataInitializeScalingDataForDefender(libMapM_ge_JungleCampDefenderTypes_BossCamp1, "OverwatchBossScaling");

}



void libOVER_gf_InitTrioGroupMercCampSiegeCamp3 () {

    // Variable Declarations

    int lv_campType;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_campType = (libMapM_ge_JungleCampDefenderTypes_SiegeCamp3);



    // Implementation

    TriggerEnable(libOVER_gt_PlayerPicksUpDragonSpirits, true);

    TriggerEnable(libOVER_gt_PlayerDiesWithDragonSpirits, true);

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_campTypeMinimapLabel = StringExternal("Param/Value/lib_OVER_87517146");

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_aIGoalLink = "MercenaryCampVision";

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_campTypeMinimapTitleLabel = StringExternal("Param/Value/lib_OVER_48B58311");

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_customTextTagTitle = StringExternal("Param/Value/lib_OVER_2D16B64B");

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_customTextTagInfoText = StringExternal("Param/Value/lib_OVER_B7FFBCBC");

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_campIsSoloable = true;

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_initialSpawnDelay = libMapM_gv_genericMercCampInitialSpawnDelay_C;

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_respawnTime = 120.0;

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_numberOfCreeps = 3;

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_creepUnitTypes[1] = "MercDefenderMeleeBruiser";

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_creepUnitTypes[2] = "MercDefenderMeleeBruiser2";

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_creepUnitTypes[3] = "MercDefenderMeleeBruiser3";

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_xPAwardForCapture = libOVER_gv_data_XP_TrioGroupCampCapture;

    libMapM_gv_dataJungleCampMercData[lv_campType].lv_numberOfMinionsSpawned = 0;

    libMapM_gf_DataInitializeScalingDataForDefender(libMapM_ge_JungleCampDefenderTypes_SiegeCamp3, "MeleeDefenderBruiserScaling");

    libUIUI_gf_PingCreateNewPingTarget("MercDefenderMeleeBruiser", false, StringExternal("Param/Value/lib_OVER_1602808D"), StringExternal("Param/Value/lib_OVER_287C8195"), StringExternal("Param/Value/lib_OVER_26F20FBE"), SoundLink("UI_Game_Ping_Attack", -1), SoundLink("UI_Game_Ping_Attack", -1));

    libUIUI_gf_PingSetHumanAISourceHeroVOForPingTarget(libUIUI_gf_PingLastCreatedPingTarget(), libCore_ge_HeroVOEvents_PingAttackMercCamp, libCore_ge_HeroVOEvents_AIMercCapture);

    libUIUI_gf_PingCreateNewPingTarget("MercDefenderMeleeBruiser2", false, StringExternal("Param/Value/lib_OVER_6478F204"), StringExternal("Param/Value/lib_OVER_D98A9A48"), StringExternal("Param/Value/lib_OVER_BC208D48"), SoundLink("UI_Game_Ping_Attack", -1), SoundLink("UI_Game_Ping_Attack", -1));

    libUIUI_gf_PingSetHumanAISourceHeroVOForPingTarget(libUIUI_gf_PingLastCreatedPingTarget(), libCore_ge_HeroVOEvents_PingAttackMercCamp, libCore_ge_HeroVOEvents_AIMercCapture);

    libUIUI_gf_PingCreateNewPingTarget("MercDefenderMeleeBruiser3", false, StringExternal("Param/Value/lib_OVER_96D84681"), StringExternal("Param/Value/lib_OVER_B001954E"), StringExternal("Param/Value/lib_OVER_B11F0D0A"), SoundLink("UI_Game_Ping_Attack", -1), SoundLink("UI_Game_Ping_Attack", -1));

    libUIUI_gf_PingSetHumanAISourceHeroVOForPingTarget(libUIUI_gf_PingLastCreatedPingTarget(), libCore_ge_HeroVOEvents_PingAttackMercCamp, libCore_ge_HeroVOEvents_AIMercCapture);

    libUIUI_gf_PingCreateNewPingTarget("DragonSpiritsPickup", false, StringExternal("Param/Value/lib_OVER_D0031FCE"), StringExternal("Param/Value/lib_OVER_B7533A08"), StringExternal("Param/Value/lib_OVER_C19333DA"), SoundLink("UI_Game_Ping_General", -1), SoundLink("UI_Game_Ping_General", -1));

}



void libOVER_gf_InitIndividualMercCampBruiserCamp3 () {

    // Variable Declarations

    int lv_campType;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_campType = (libMapM_ge_JungleCampDefenderTypes_BruiserCamp3);



    // Implementation

    TriggerEnable(libOVER_gt_PlayerPicksUpHealingPulse, true);

    TriggerEnable(libOVER_gt_PlayerDiesWithHealingPulse, true);

    TriggerEnable(libOVER_gt_BioticEmitterScaling, true);

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_campTypeMinimapLabel = StringExternal("Param/Value/lib_OVER_10917A4A");

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_campIsElite = true;

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_aIGoalLink = "MercenaryCampSupport";

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_campTypeMinimapTitleLabel = StringExternal("Param/Value/lib_OVER_D10BAD20");

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_customTextTagTitle = StringExternal("Param/Value/lib_OVER_6A3E7449");

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_customTextTagInfoText = StringExternal("Param/Value/lib_OVER_4AAA4585");

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_campIsSoloable = false;

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_initialSpawnDelay = libMapM_gv_genericMercCampInitialSpawnDelay_C;

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_respawnTime = 180.0;

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_numberOfCreeps = 1;

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_creepUnitTypes[1] = "MercDefenderMeleeIndividual";

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_xPAwardForCapture = libOVER_gv_data_XP_IndividualCampCapture;

    libMapM_gv_dataJungleCampMercData[lv_campType].lv_numberOfMinionsSpawned = 0;

    libMapM_gf_DataInitializeScalingDataForDefender(libMapM_ge_JungleCampDefenderTypes_BruiserCamp3, "MercDefenderIndividualCampScaling");

    libUIUI_gf_PingCreateNewPingTarget("MercDefenderMeleeIndividual", false, StringExternal("Param/Value/lib_OVER_EF6E1819"), StringExternal("Param/Value/lib_OVER_C2289DE7"), StringExternal("Param/Value/lib_OVER_23AB7604"), SoundLink("UI_Game_Ping_Attack", -1), SoundLink("UI_Game_Ping_Attack", -1));

    libUIUI_gf_PingSetHumanAISourceHeroVOForPingTarget(libUIUI_gf_PingLastCreatedPingTarget(), libCore_ge_HeroVOEvents_PingAttackMercCamp, libCore_ge_HeroVOEvents_AIMercCapture);

    libUIUI_gf_PingCreateNewPingTarget("HealingPulsePickup", false, StringExternal("Param/Value/lib_OVER_A2872802"), StringExternal("Param/Value/lib_OVER_BA373CE2"), StringExternal("Param/Value/lib_OVER_4E0E5943"), SoundLink("UI_Game_Ping_General", -1), SoundLink("UI_Game_Ping_General", -1));

}



void libOVER_gf_InitTurretMercCampSiegeCamp1 () {

    // Variable Declarations

    int lv_campType;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_campType = (libMapM_ge_JungleCampDefenderTypes_SiegeCamp1);



    // Implementation

    TriggerEnable(libOVER_gt_PlayerCreatesTurretFromMapMechanicAbility, true);

    TriggerEnable(libOVER_gt_PlayerPicksUpTurretItem, true);

    TriggerEnable(libOVER_gt_PlayerDiesWithTurretItem, true);

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_campTypeMinimapLabel = StringExternal("Param/Value/lib_OVER_221294BA");

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_aIGoalLink = "MercenaryCampFortification";

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_campTypeMinimapTitleLabel = StringExternal("Param/Value/lib_OVER_88F5BC6F");

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_customTextTagTitle = StringExternal("Param/Value/lib_OVER_DAB2C82F");

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_customTextTagInfoText = StringExternal("Param/Value/lib_OVER_8E833978");

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_campIsSoloable = true;

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_initialSpawnDelay = libMapM_gv_genericMercCampInitialSpawnDelay_C;

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_respawnTime = 150.0;

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_numberOfCreeps = 2;

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_creepUnitTypes[1] = "OverwatchTurret";

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_creepUnitTypes[2] = "OverwatchMechanic";

    libMapM_gv_dataJungleCampDefenderData[lv_campType].lv_xPAwardForCapture = libOVER_gv_data_XP_TurretCampCapture;

    libMapM_gv_dataJungleCampMercData[lv_campType].lv_numberOfMinionsSpawned = 0;

    libMapM_gf_DataInitializeScalingDataForDefender(libMapM_ge_JungleCampDefenderTypes_SiegeCamp1, "OverwatchTurretScaling");

    libMapM_gf_DataInitializeScalingDataForMerc(libMapM_ge_JungleCampMercTypes_SiegeCamp1, "OverwatchMechanicScaling");

    libUIUI_gf_PingCreateNewPingTarget("TurretPickup", false, StringExternal("Param/Value/lib_OVER_E59B469A"), StringExternal("Param/Value/lib_OVER_F88686E8"), StringExternal("Param/Value/lib_OVER_3AF565FD"), SoundLink("UI_Game_Ping_General", -1), SoundLink("UI_Game_Ping_General", -1));

    libUIUI_gf_PingCreateNewPingTarget("OverwatchTurretPlayer", false, StringExternal("Param/Value/lib_OVER_80BD7C33"), StringExternal("Param/Value/lib_OVER_A3E0517E"), StringExternal("Param/Value/lib_OVER_DD14DDAA"), SoundLink("UI_Game_Ping_Attack", -1), SoundLink("UI_Game_Ping_Attack", -1));

    libUIUI_gf_PingCreateNewPingTarget("OverwatchTurret", false, StringExternal("Param/Value/lib_OVER_2F368079"), StringExternal("Param/Value/lib_OVER_9464E0AD"), StringExternal("Param/Value/lib_OVER_87C571B3"), SoundLink("UI_Game_Ping_Attack", -1), SoundLink("UI_Game_Ping_Attack", -1));

    libUIUI_gf_PingSetHumanAISourceHeroVOForPingTarget(libUIUI_gf_PingLastCreatedPingTarget(), libCore_ge_HeroVOEvents_PingAttackMercCamp, libCore_ge_HeroVOEvents_AIMercCapture);

    libUIUI_gf_PingCreateNewPingTarget("OverwatchMechanic", false, StringExternal("Param/Value/lib_OVER_8F5D8AB1"), StringExternal("Param/Value/lib_OVER_9F471E44"), StringExternal("Param/Value/lib_OVER_32D81809"), SoundLink("UI_Game_Ping_Attack", -1), SoundLink("UI_Game_Ping_Attack", -1));

    libUIUI_gf_PingSetHumanAISourceHeroVOForPingTarget(libUIUI_gf_PingLastCreatedPingTarget(), libCore_ge_HeroVOEvents_PingAttackMercCamp, libCore_ge_HeroVOEvents_AIMercCapture);

}



// Triggers

//--------------------------------------------------------------------------------------------------

// Trigger: Scaling Timer Expires

//--------------------------------------------------------------------------------------------------

bool libOVER_gt_ScalingTimerExpires_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libOVER_gv_overwatchModExtraScalingEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libOVER_gv_data_XP_TurretCampCapture += 10.0;

    libOVER_gv_data_XP_BossCampCapture += 10.0;

    libOVER_gv_data_XP_TrioGroupCampCapture += 10.0;

    libOVER_gv_data_XP_IndividualCampCapture += 10.0;

    libMapM_gv_dataJungleCampDefenderData[(libMapM_ge_JungleCampDefenderTypes_SiegeCamp1)].lv_xPAwardForCapture = libOVER_gv_data_XP_TurretCampCapture;

    libMapM_gv_dataJungleCampDefenderData[(libMapM_ge_JungleCampDefenderTypes_BossCamp1)].lv_xPAwardForCapture = libOVER_gv_data_XP_TurretCampCapture;

    libMapM_gv_dataJungleCampDefenderData[(libMapM_ge_JungleCampDefenderTypes_SiegeCamp3)].lv_xPAwardForCapture = libOVER_gv_data_XP_TrioGroupCampCapture;

    libMapM_gv_dataJungleCampDefenderData[(libMapM_ge_JungleCampDefenderTypes_BruiserCamp3)].lv_xPAwardForCapture = libOVER_gv_data_XP_IndividualCampCapture;

    return true;

}



//--------------------------------------------------------------------------------------------------

void libOVER_gt_ScalingTimerExpires_Init () {

    libOVER_gt_ScalingTimerExpires = TriggerCreate("libOVER_gt_ScalingTimerExpires_Func");

    libGame_gf_ScalingIncremented(libOVER_gt_ScalingTimerExpires);

}



//--------------------------------------------------------------------------------------------------

// Trigger: Boss Eats Player

//--------------------------------------------------------------------------------------------------

bool libOVER_gt_BossEatsPlayer_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_bossUnit;

    unit lv_targetUnit;

    int lv_targetAllyTeam;

    int lv_targetEnemyTeam;

    fixed lv_bossEatingDuration;

    timer lv_eatingTimer;

    int lv_selfTextTag;

    int lv_allyTextTag;

    int lv_enemyTextTag;

    playergroup lv_allyPlayerGroup;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_bossUnit = EventPlayerEffectUsedUnit(c_effectUnitCaster);

    lv_targetUnit = EventPlayerEffectUsedUnitImpact();

    lv_targetAllyTeam = libGame_gf_TeamNumberOfPlayer(UnitGetOwner(lv_targetUnit));

    lv_targetEnemyTeam = libGame_gf_EnemyTeam(lv_targetAllyTeam);

    lv_bossEatingDuration = 4.9375;

    lv_eatingTimer = TimerCreate();

    lv_selfTextTag = c_textTagNone;

    lv_allyTextTag = c_textTagNone;

    lv_enemyTextTag = c_textTagNone;

    lv_allyPlayerGroup = PlayerGroupCopy(libGame_gf_PlayersOnTeamHeroes(lv_targetAllyTeam, false));



    // Actions

    if (!runActions) {

        return true;

    }



    if ((UnitIsValid(lv_bossUnit) == false)) {

        return true;

    }



    PlayerGroupRemove(lv_allyPlayerGroup, UnitGetOwner(lv_targetUnit));

    TimerStart(lv_eatingTimer, lv_bossEatingDuration, false, c_timeGame);

    TextExpressionSetToken("Param/Expression/lib_OVER_1211D4BF", "B", UnitTypeGetName(UnitGetType(lv_targetUnit)));

    TextExpressionSetToken("Param/Expression/lib_OVER_1211D4BF", "A", FixedToText(TimerGetRemaining(lv_eatingTimer), 0));

    TextTagCreate(TextExpressionAssemble("Param/Expression/lib_OVER_1211D4BF"), 24, UnitGetPosition(lv_bossUnit), 1.0, true, true, PlayerGroupSingle(UnitGetOwner(lv_targetUnit)));

    lv_selfTextTag = TextTagLastCreated();

    TextExpressionSetToken("Param/Expression/lib_OVER_FDBAA0B1", "B", UnitTypeGetName(UnitGetType(lv_targetUnit)));

    TextExpressionSetToken("Param/Expression/lib_OVER_FDBAA0B1", "A", FixedToText(TimerGetRemaining(lv_eatingTimer), 0));

    TextTagCreate(TextExpressionAssemble("Param/Expression/lib_OVER_FDBAA0B1"), 24, UnitGetPosition(lv_bossUnit), 1.0, true, true, lv_allyPlayerGroup);

    lv_allyTextTag = TextTagLastCreated();

    TextExpressionSetToken("Param/Expression/lib_OVER_9D93A1A1", "B", UnitTypeGetName(UnitGetType(lv_targetUnit)));

    TextExpressionSetToken("Param/Expression/lib_OVER_9D93A1A1", "A", FixedToText(TimerGetRemaining(lv_eatingTimer), 0));

    TextTagCreate(TextExpressionAssemble("Param/Expression/lib_OVER_9D93A1A1"), 24, UnitGetPosition(lv_bossUnit), 1.0, true, true, libGame_gf_PlayersOnTeamHeroes(lv_targetEnemyTeam, false));

    TextTagSetFogVisibility(TextTagLastCreated(), c_visTypeFog);

    lv_enemyTextTag = TextTagLastCreated();

    TextTagAttachToUnit(lv_allyTextTag, lv_bossUnit, 5.0);

    TextTagAttachToUnit(lv_enemyTextTag, lv_bossUnit, 5.0);

    TextTagAttachToUnit(lv_selfTextTag, lv_bossUnit, 5.0);

    if ((UnitTestState(lv_targetUnit, c_unitStateHallucination) == false) && (UnitIsAlive(lv_targetUnit) == true) && (UnitHasBehavior2(lv_targetUnit, "HeroGenericIgnoreFullscreenOverlay") == false)) {

        libUIUI_gf_FullscreenOverlayAddItemForPlayer(UnitGetOwner(lv_targetUnit), libUIUI_ge_FullscreenOverlayPriorities_Stasis, "Cutscenes\\GameUI_OverwatchBossImprisonOverlay.StormCutscene", "OverwatchBossBeingImprisonedBehavior");

    }



    UnitBehaviorSetDurationRemaining(lv_targetUnit, "OverwatchBossImprisonedBehavior", (lv_bossEatingDuration + 0.0625));

    while ((UnitIsValid(lv_bossUnit) == true) && (TimerGetRemaining(lv_eatingTimer) > 0.0)) {

        if ((UnitTestState(lv_bossUnit, c_unitStateInStasis) == false)) {

            TimerPause(lv_eatingTimer, false);

            if ((TimerGetRemaining(lv_eatingTimer) > 1.0)) {

                TextExpressionSetToken("Param/Expression/lib_OVER_72963902", "B", UnitTypeGetName(UnitGetType(lv_targetUnit)));

                TextExpressionSetToken("Param/Expression/lib_OVER_72963902", "A", FixedToText(TimerGetRemaining(lv_eatingTimer), 0));

                TextTagSetText(lv_allyTextTag, TextExpressionAssemble("Param/Expression/lib_OVER_72963902"));

                TextExpressionSetToken("Param/Expression/lib_OVER_FBAC456E", "B", UnitTypeGetName(UnitGetType(lv_targetUnit)));

                TextExpressionSetToken("Param/Expression/lib_OVER_FBAC456E", "A", FixedToText(TimerGetRemaining(lv_eatingTimer), 0));

                TextTagSetText(lv_enemyTextTag, TextExpressionAssemble("Param/Expression/lib_OVER_FBAC456E"));

                TextExpressionSetToken("Param/Expression/lib_OVER_39000723", "B", UnitTypeGetName(UnitGetType(lv_targetUnit)));

                TextExpressionSetToken("Param/Expression/lib_OVER_39000723", "A", FixedToText(TimerGetRemaining(lv_eatingTimer), 0));

                TextTagSetText(lv_selfTextTag, TextExpressionAssemble("Param/Expression/lib_OVER_39000723"));

                Wait(1.0, c_timeGame);

            }

            else {

                TextExpressionSetToken("Param/Expression/lib_OVER_A9804111", "B", UnitTypeGetName(UnitGetType(lv_targetUnit)));

                TextExpressionSetToken("Param/Expression/lib_OVER_A9804111", "A", FixedToText(TimerGetRemaining(lv_eatingTimer), 0));

                TextTagSetText(lv_allyTextTag, TextExpressionAssemble("Param/Expression/lib_OVER_A9804111"));

                TextExpressionSetToken("Param/Expression/lib_OVER_EDB9F42B", "B", UnitTypeGetName(UnitGetType(lv_targetUnit)));

                TextExpressionSetToken("Param/Expression/lib_OVER_EDB9F42B", "A", FixedToText(TimerGetRemaining(lv_eatingTimer), 1));

                TextTagSetText(lv_enemyTextTag, TextExpressionAssemble("Param/Expression/lib_OVER_EDB9F42B"));

                TextExpressionSetToken("Param/Expression/lib_OVER_86245AA3", "B", UnitTypeGetName(UnitGetType(lv_targetUnit)));

                TextExpressionSetToken("Param/Expression/lib_OVER_86245AA3", "A", FixedToText(TimerGetRemaining(lv_eatingTimer), 1));

                TextTagSetText(lv_selfTextTag, TextExpressionAssemble("Param/Expression/lib_OVER_86245AA3"));

                Wait(0.0625, c_timeGame);

            }

        }

        else {

            TimerPause(lv_eatingTimer, true);

            Wait(0.0625, c_timeGame);

        }

    }

    libUIUI_gf_FullscreenOverlayRemoveItemFromQueueForPlayer(UnitGetOwner(lv_targetUnit), "Cutscenes\\GameUI_OverwatchBossImprisonOverlay.StormCutscene", "OverwatchBossBeingImprisonedBehavior");

    TextTagDestroy(lv_allyTextTag);

    TextTagDestroy(lv_enemyTextTag);

    TextTagDestroy(lv_selfTextTag);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libOVER_gt_BossEatsPlayer_Init () {

    libOVER_gt_BossEatsPlayer = TriggerCreate("libOVER_gt_BossEatsPlayer_Func");

    TriggerEnable(libOVER_gt_BossEatsPlayer, false);

    TriggerAddEventPlayerEffectUsed(libOVER_gt_BossEatsPlayer, 15, "OverwatchBossImprisonApplyImprisonedBehavior");

}



//--------------------------------------------------------------------------------------------------

// Trigger: Player Picks Up Healing Pulse

//--------------------------------------------------------------------------------------------------

bool libOVER_gt_PlayerPicksUpHealingPulse_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_casterUnit;

    unit lv_targetUnit;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_casterUnit = EventPlayerEffectUsedUnit(c_effectUnitCaster);

    lv_targetUnit = EventPlayerEffectUsedUnit(c_effectUnitTarget);



    // Conditions

    if (testConds) {

        if (!((EventPlayerEffectUsedUnitType(c_effectUnitTarget) == "HealingPulsePickup"))) {

            return false;

        }



        if (!((UnitGroupHasUnit(libOVER_gv_itemsOnGround, lv_targetUnit) == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libOVER_gf_HeroPicksUpItem(lv_casterUnit, lv_targetUnit, UnitGetPosition(lv_targetUnit));

    UnitBehaviorAdd(lv_casterUnit, "HasMapMechanicTargetAbility2", lv_casterUnit, 1);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libOVER_gt_PlayerPicksUpHealingPulse_Init () {

    libOVER_gt_PlayerPicksUpHealingPulse = TriggerCreate("libOVER_gt_PlayerPicksUpHealingPulse_Func");

    TriggerEnable(libOVER_gt_PlayerPicksUpHealingPulse, false);

    TriggerAddEventPlayerEffectUsed(libOVER_gt_PlayerPicksUpHealingPulse, c_playerAny, "CaptureMacGuffinCastComplete");

}



//--------------------------------------------------------------------------------------------------

// Trigger: Player Dies With Healing Pulse

//--------------------------------------------------------------------------------------------------

bool libOVER_gt_PlayerDiesWithHealingPulse_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_heroKilledUnit;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_heroKilledUnit = libGame_gf_HeroKilledUnit();



    // Conditions

    if (testConds) {

        if (!((UnitHasBehavior2(lv_heroKilledUnit, "HasMapMechanicTargetAbility2") == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    UnitBehaviorRemove(lv_heroKilledUnit, "HasMapMechanicTargetAbility2", 1);

    libOVER_gf_HeroDiesWithItem("HealingPulsePickup", libGame_gf_HeroKilledLocation(), StringExternal("Param/Value/lib_OVER_AFDE5102"));

    return true;

}



//--------------------------------------------------------------------------------------------------

void libOVER_gt_PlayerDiesWithHealingPulse_Init () {

    libOVER_gt_PlayerDiesWithHealingPulse = TriggerCreate("libOVER_gt_PlayerDiesWithHealingPulse_Func");

    TriggerEnable(libOVER_gt_PlayerDiesWithHealingPulse, false);

    libGame_gf_HeroKilled(libOVER_gt_PlayerDiesWithHealingPulse);

}



//--------------------------------------------------------------------------------------------------

// Trigger: Biotic Emitter Scaling

//--------------------------------------------------------------------------------------------------

bool libOVER_gt_BioticEmitterScaling_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Actions

    if (!runActions) {

        return true;

    }



    UnitXPAddXP(EventUnitCreatedUnit(), "BioticEmitterScaling", libGame_gv_teams[libGame_gf_TeamNumberOfPlayer(UnitGetOwner(EventUnit()))].lv_teamLevel);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libOVER_gt_BioticEmitterScaling_Init () {

    libOVER_gt_BioticEmitterScaling = TriggerCreate("libOVER_gt_BioticEmitterScaling_Func");

    TriggerEnable(libOVER_gt_BioticEmitterScaling, false);

    TriggerAddEventUnitCreated(libOVER_gt_BioticEmitterScaling, null, "MapMechanicAbilityTarget2", null);

}



//--------------------------------------------------------------------------------------------------

// Trigger: Player Picks Up Dragon Spirits

//--------------------------------------------------------------------------------------------------

bool libOVER_gt_PlayerPicksUpDragonSpirits_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_casterUnit;

    unit lv_targetUnit;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_casterUnit = EventPlayerEffectUsedUnit(c_effectUnitCaster);

    lv_targetUnit = EventPlayerEffectUsedUnit(c_effectUnitTarget);



    // Conditions

    if (testConds) {

        if (!((EventPlayerEffectUsedUnitType(c_effectUnitTarget) == "DragonSpiritsPickup"))) {

            return false;

        }



        if (!((UnitGroupHasUnit(libOVER_gv_itemsOnGround, lv_targetUnit) == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    UnitCreateEffectUnit(lv_casterUnit, "CaptureMacguffinTargetIsDragonSpiritsModifyPlayerProperties", lv_casterUnit);

    libOVER_gf_HeroPicksUpItem(lv_casterUnit, lv_targetUnit, UnitGetPosition(lv_targetUnit));

    UnitBehaviorAdd(lv_casterUnit, "HasMapMechanicInstantAbility", lv_casterUnit, 1);

    UnitBehaviorAdd(lv_casterUnit, "HasMapMechanicInstantAbility2", lv_casterUnit, 1);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libOVER_gt_PlayerPicksUpDragonSpirits_Init () {

    libOVER_gt_PlayerPicksUpDragonSpirits = TriggerCreate("libOVER_gt_PlayerPicksUpDragonSpirits_Func");

    TriggerEnable(libOVER_gt_PlayerPicksUpDragonSpirits, false);

    TriggerAddEventPlayerEffectUsed(libOVER_gt_PlayerPicksUpDragonSpirits, c_playerAny, "CaptureMacGuffinCastComplete");

}



//--------------------------------------------------------------------------------------------------

// Trigger: Player Dies With Dragon Spirits

//--------------------------------------------------------------------------------------------------

bool libOVER_gt_PlayerDiesWithDragonSpirits_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_heroKilledUnit;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_heroKilledUnit = libGame_gf_HeroKilledUnit();



    // Conditions

    if (testConds) {

        if (!((UnitHasBehavior2(lv_heroKilledUnit, "HasMapMechanicInstantAbility") == true))) {

            return false;

        }



        if (!((UnitHasBehavior2(lv_heroKilledUnit, "HasMapMechanicInstantAbility2") == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    UnitBehaviorRemove(lv_heroKilledUnit, "HasMapMechanicInstantAbility", 1);

    UnitBehaviorRemove(lv_heroKilledUnit, "HasMapMechanicInstantAbility2", 1);

    libOVER_gf_HeroDiesWithItem("DragonSpiritsPickup", libGame_gf_HeroKilledLocation(), StringExternal("Param/Value/lib_OVER_D8EF563E"));

    return true;

}



//--------------------------------------------------------------------------------------------------

void libOVER_gt_PlayerDiesWithDragonSpirits_Init () {

    libOVER_gt_PlayerDiesWithDragonSpirits = TriggerCreate("libOVER_gt_PlayerDiesWithDragonSpirits_Func");

    TriggerEnable(libOVER_gt_PlayerDiesWithDragonSpirits, false);

    libGame_gf_HeroKilled(libOVER_gt_PlayerDiesWithDragonSpirits);

}



//--------------------------------------------------------------------------------------------------

// Trigger: Player Creates Turret From Map Mechanic Ability

//--------------------------------------------------------------------------------------------------

bool libOVER_gt_PlayerCreatesTurretFromMapMechanicAbility_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((UnitGetType(EventUnitCreatedUnit()) == "OverwatchTurretPlayer"))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    UnitXPAddXP(EventUnitCreatedUnit(), "OverwatchTurretPlayerScaling", libGame_gv_teams[libGame_gf_TeamNumberOfPlayer(UnitGetOwner(EventUnit()))].lv_teamLevel);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libOVER_gt_PlayerCreatesTurretFromMapMechanicAbility_Init () {

    libOVER_gt_PlayerCreatesTurretFromMapMechanicAbility = TriggerCreate("libOVER_gt_PlayerCreatesTurretFromMapMechanicAbility_Func");

    TriggerEnable(libOVER_gt_PlayerCreatesTurretFromMapMechanicAbility, false);

    TriggerAddEventUnitCreated(libOVER_gt_PlayerCreatesTurretFromMapMechanicAbility, null, "MapMechanicAbilityTarget", null);

}



//--------------------------------------------------------------------------------------------------

// Trigger: Player Picks Up Turret Item

//--------------------------------------------------------------------------------------------------

bool libOVER_gt_PlayerPicksUpTurretItem_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_casterUnit;

    unit lv_targetUnit;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_casterUnit = EventPlayerEffectUsedUnit(c_effectUnitCaster);

    lv_targetUnit = EventPlayerEffectUsedUnit(c_effectUnitTarget);



    // Conditions

    if (testConds) {

        if (!((EventPlayerEffectUsedUnitType(c_effectUnitTarget) == "TurretPickup"))) {

            return false;

        }



        if (!((UnitGroupHasUnit(libOVER_gv_itemsOnGround, lv_targetUnit) == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libOVER_gf_HeroPicksUpItem(lv_casterUnit, lv_targetUnit, UnitGetPosition(lv_targetUnit));

    UnitBehaviorAdd(lv_casterUnit, "HasMapMechanicTargetAbility", lv_casterUnit, 1);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libOVER_gt_PlayerPicksUpTurretItem_Init () {

    libOVER_gt_PlayerPicksUpTurretItem = TriggerCreate("libOVER_gt_PlayerPicksUpTurretItem_Func");

    TriggerEnable(libOVER_gt_PlayerPicksUpTurretItem, false);

    TriggerAddEventPlayerEffectUsed(libOVER_gt_PlayerPicksUpTurretItem, c_playerAny, "CaptureMacGuffinCastComplete");

}



//--------------------------------------------------------------------------------------------------

// Trigger: Player Dies With Turret Item

//--------------------------------------------------------------------------------------------------

bool libOVER_gt_PlayerDiesWithTurretItem_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_heroKilledUnit;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_heroKilledUnit = libGame_gf_HeroKilledUnit();



    // Conditions

    if (testConds) {

        if (!((UnitHasBehavior2(lv_heroKilledUnit, "HasMapMechanicTargetAbility") == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    UnitBehaviorRemove(lv_heroKilledUnit, "HasMapMechanicTargetAbility", 1);

    libOVER_gf_HeroDiesWithItem("TurretPickup", libGame_gf_HeroKilledLocation(), StringExternal("Param/Value/lib_OVER_97E6FCFF"));

    return true;

}



//--------------------------------------------------------------------------------------------------

void libOVER_gt_PlayerDiesWithTurretItem_Init () {

    libOVER_gt_PlayerDiesWithTurretItem = TriggerCreate("libOVER_gt_PlayerDiesWithTurretItem_Func");

    TriggerEnable(libOVER_gt_PlayerDiesWithTurretItem, false);

    libGame_gf_HeroKilled(libOVER_gt_PlayerDiesWithTurretItem);

}



//--------------------------------------------------------------------------------------------------

// Trigger: Merc Camp Killed

//--------------------------------------------------------------------------------------------------

bool libOVER_gt_MercCampKilled_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_index;

    unit lv_chestUnit;



    // Automatic Variable Declarations

    const int auto75855403_ae = libMapM_gv_jungleMaxCamps;

    const int auto75855403_ai = 1;



    // Variable Initialization

    lv_chestUnit = UnitGroupUnit(UnitGroup("OWPickupChest", libCore_gv_cOMPUTER_Neutral, libAIAI_gf_DefenderLeashRegion(libGame_gf_JungleDefenderAIAllDefendersKilledIndex()), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 1), 1);



    // Actions

    if (!runActions) {

        return true;

    }



    lv_index = 1;

    for ( ; ( (auto75855403_ai >= 0 && lv_index <= auto75855403_ae) || (auto75855403_ai < 0 && lv_index >= auto75855403_ae) ) ; lv_index += auto75855403_ai ) {

        if ((libMapM_gv_jungleCreepCamps[lv_index].lv_aIDefenderAIIndex == libGame_gf_JungleDefenderAIAllDefendersKilledIndex())) {

            if ((libMapM_gv_jungleCreepCamps[lv_index].lv_mapDataCampDefenderType == libMapM_ge_JungleCampDefenderTypes_BruiserCamp3)) {

                libNtve_gf_SendActorMessageToUnit(lv_chestUnit, "StatusSet HealingPulse 1");

            }

            else if ((libMapM_gv_jungleCreepCamps[lv_index].lv_mapDataCampDefenderType == libMapM_ge_JungleCampDefenderTypes_SiegeCamp3)) {

                libNtve_gf_SendActorMessageToUnit(lv_chestUnit, "StatusSet DragonSpirits 1");

            }

            else if ((libMapM_gv_jungleCreepCamps[lv_index].lv_mapDataCampDefenderType == libMapM_ge_JungleCampDefenderTypes_SiegeCamp1)) {

                libNtve_gf_SendActorMessageToUnit(lv_chestUnit, "StatusSet Turret 1");

            }

            break;

        }



    }

    libNtve_gf_SendActorMessageToUnit(lv_chestUnit, "Signal SpawnItem");

    return true;

}



//--------------------------------------------------------------------------------------------------

void libOVER_gt_MercCampKilled_Init () {

    libOVER_gt_MercCampKilled = TriggerCreate("libOVER_gt_MercCampKilled_Func");

    libGame_gf_JungleDefenderAIAllDefendersKilled(libOVER_gt_MercCampKilled);

}



//--------------------------------------------------------------------------------------------------

// Trigger: Merc Camp Captured

//--------------------------------------------------------------------------------------------------

bool libOVER_gt_MercCampCaptured_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_chestUnit;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_chestUnit = UnitGroupUnit(UnitGroup("OWPickupChest", libCore_gv_cOMPUTER_Neutral, libMapM_gv_jungleCreepCamps[libGame_gf_MercCampRewardGrantedCampIndex()].lv_mapDataDefenderLeashRegion, UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 1), 1);



    // Actions

    if (!runActions) {

        return true;

    }



    if ((libMapM_gv_jungleCreepCamps[libGame_gf_MercCampRewardGrantedCampIndex()].lv_mapDataCampDefenderType == libMapM_ge_JungleCampDefenderTypes_BruiserCamp3)) {

        UnitCreateEffectPoint(lv_chestUnit, "OWPickupChestHealingPulseLaunchMissile", libMapM_gv_jungleCreepCamps[libGame_gf_MercCampRewardGrantedCampIndex()].lv_mapDataCampCaptainSpawnPoint);

    }

    else if ((libMapM_gv_jungleCreepCamps[libGame_gf_MercCampRewardGrantedCampIndex()].lv_mapDataCampDefenderType == libMapM_ge_JungleCampDefenderTypes_SiegeCamp3)) {

        UnitCreateEffectPoint(lv_chestUnit, "OWPickupChestDragonSpiritsLaunchMissile", libMapM_gv_jungleCreepCamps[libGame_gf_MercCampRewardGrantedCampIndex()].lv_mapDataCampCaptainSpawnPoint);

    }

    else if ((libMapM_gv_jungleCreepCamps[libGame_gf_MercCampRewardGrantedCampIndex()].lv_mapDataCampDefenderType == libMapM_ge_JungleCampDefenderTypes_SiegeCamp1)) {

        UnitCreateEffectPoint(lv_chestUnit, "OWPickupChestTurretLaunchMissile", libMapM_gv_jungleCreepCamps[libGame_gf_MercCampRewardGrantedCampIndex()].lv_mapDataCampCaptainSpawnPoint);

    }

    libNtve_gf_SendActorMessageToUnit(lv_chestUnit, "Signal ItemSpawned");

    return true;

}



//--------------------------------------------------------------------------------------------------

void libOVER_gt_MercCampCaptured_Init () {

    libOVER_gt_MercCampCaptured = TriggerCreate("libOVER_gt_MercCampCaptured_Func");

    libGame_gf_MercCampRewardGranted(libOVER_gt_MercCampCaptured);

}



//--------------------------------------------------------------------------------------------------

// Trigger: Item Spawned

//--------------------------------------------------------------------------------------------------

bool libOVER_gt_ItemSpawned_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_itemUnit;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_itemUnit = EventPlayerEffectUsedUnit(c_effectUnitSource);



    // Actions

    if (!runActions) {

        return true;

    }



    UnitGroupAdd(libOVER_gv_itemsOnGround, lv_itemUnit);

    Wait(0.5, c_timeGame);

    if ((UnitGetType(lv_itemUnit) == "HealingPulsePickup")) {

        TextTagCreate(StringExternal("Param/Value/lib_OVER_6B0FC639"), 24, UnitGetPosition(lv_itemUnit), 3.0, false, false, PlayerGroupAll());

    }

    else if ((UnitGetType(lv_itemUnit) == "DragonSpiritsPickup")) {

        TextTagCreate(StringExternal("Param/Value/lib_OVER_0FF3B904"), 24, UnitGetPosition(lv_itemUnit), 3.0, false, false, PlayerGroupAll());

    }

    else if ((UnitGetType(lv_itemUnit) == "TurretPickup")) {

        TextTagCreate(StringExternal("Param/Value/lib_OVER_8D4D576D"), 24, UnitGetPosition(lv_itemUnit), 3.0, false, false, PlayerGroupAll());

    }

    TextTagAttachToUnit(TextTagLastCreated(), lv_itemUnit, 3.0);

    libCore_gf_StoreTextTagForUnit(lv_itemUnit, 1, TextTagLastCreated());

    libOVER_gf_ShareVisionofItemPickup(lv_itemUnit);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libOVER_gt_ItemSpawned_Init () {

    libOVER_gt_ItemSpawned = TriggerCreate("libOVER_gt_ItemSpawned_Func");

    TriggerAddEventPlayerEffectUsed(libOVER_gt_ItemSpawned, libCore_gv_cOMPUTER_Neutral, "OWPickupChestItemCreatedDummyPersistent");

}



//--------------------------------------------------------------------------------------------------

// Trigger: Create Order Item Interact Goal

//--------------------------------------------------------------------------------------------------

bool libOVER_gt_CreateOrderItemInteractGoal_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_itemUnit;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_itemUnit = EventPlayerEffectUsedUnit(c_effectUnitSource);



    // Actions

    if (!runActions) {

        return true;

    }



    if ((libAIAI_gf_HeroAITeamHasHumanPlayers(libGame_ge_Faction_Order) == true)) {

        Wait(2.0, c_timeGame);

        AddUnitOfInterest(lv_itemUnit, 0.0, 0.0, "PickupOverwatchItem", libNtve_ge_GoalTeam_Order, 0);

    }

    else {

        AddUnitOfInterest(lv_itemUnit, 0.0, 0.0, "PickupOverwatchItem", libNtve_ge_GoalTeam_Order, 0);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libOVER_gt_CreateOrderItemInteractGoal_Init () {

    libOVER_gt_CreateOrderItemInteractGoal = TriggerCreate("libOVER_gt_CreateOrderItemInteractGoal_Func");

    TriggerAddEventPlayerEffectUsed(libOVER_gt_CreateOrderItemInteractGoal, libCore_gv_cOMPUTER_Neutral, "OWPickupChestItemCreatedDummyPersistent");

}



//--------------------------------------------------------------------------------------------------

// Trigger: Create Chaos Item Interact Goal

//--------------------------------------------------------------------------------------------------

bool libOVER_gt_CreateChaosItemInteractGoal_Func (bool testConds, bool runActions) {

    // Variable Declarations

    unit lv_itemUnit;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_itemUnit = EventPlayerEffectUsedUnit(c_effectUnitSource);



    // Actions

    if (!runActions) {

        return true;

    }



    if ((libAIAI_gf_HeroAITeamHasHumanPlayers(libGame_ge_Faction_Chaos) == true)) {

        Wait(2.0, c_timeGame);

        AddUnitOfInterest(lv_itemUnit, 0.0, 0.0, "PickupOverwatchItem", libNtve_ge_GoalTeam_Chaos, 0);

    }

    else {

        AddUnitOfInterest(lv_itemUnit, 0.0, 0.0, "PickupOverwatchItem", libNtve_ge_GoalTeam_Chaos, 0);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libOVER_gt_CreateChaosItemInteractGoal_Init () {

    libOVER_gt_CreateChaosItemInteractGoal = TriggerCreate("libOVER_gt_CreateChaosItemInteractGoal_Func");

    TriggerAddEventPlayerEffectUsed(libOVER_gt_CreateChaosItemInteractGoal, libCore_gv_cOMPUTER_Neutral, "OWPickupChestItemCreatedDummyPersistent");

}



//--------------------------------------------------------------------------------------------------

// Trigger: Show Map Mechanic Button

//--------------------------------------------------------------------------------------------------

bool libOVER_gt_ShowMapMechanicButton_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Actions

    if (!runActions) {

        return true;

    }



    libUIUI_gf_UIEnableMapMechanicButtonAllPlayers(true);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libOVER_gt_ShowMapMechanicButton_Init () {

    libOVER_gt_ShowMapMechanicButton = TriggerCreate("libOVER_gt_ShowMapMechanicButton_Func");

    libCore_gf_IncludeModInitialization(libOVER_gt_ShowMapMechanicButton);

}



void libOVER_InitTriggers () {

    libOVER_gt_ScalingTimerExpires_Init();

    libOVER_gt_BossEatsPlayer_Init();

    libOVER_gt_PlayerPicksUpHealingPulse_Init();

    libOVER_gt_PlayerDiesWithHealingPulse_Init();

    libOVER_gt_BioticEmitterScaling_Init();

    libOVER_gt_PlayerPicksUpDragonSpirits_Init();

    libOVER_gt_PlayerDiesWithDragonSpirits_Init();

    libOVER_gt_PlayerCreatesTurretFromMapMechanicAbility_Init();

    libOVER_gt_PlayerPicksUpTurretItem_Init();

    libOVER_gt_PlayerDiesWithTurretItem_Init();

    libOVER_gt_MercCampKilled_Init();

    libOVER_gt_MercCampCaptured_Init();

    libOVER_gt_ItemSpawned_Init();

    libOVER_gt_CreateOrderItemInteractGoal_Init();

    libOVER_gt_CreateChaosItemInteractGoal_Init();

    libOVER_gt_ShowMapMechanicButton_Init();

}



//--------------------------------------------------------------------------------------------------

// Library Initialization

//--------------------------------------------------------------------------------------------------

bool libOVER_InitLib_completed = false;



void libOVER_InitLib () {

    if (libOVER_InitLib_completed) {

        return;

    }



    libOVER_InitLib_completed = true;



    libOVER_InitLibraries();

    libOVER_InitVariables();

    libOVER_InitTriggers();

}