PTR build 2.57.1.98674_ptr. Go to the live site.

mods/heroesmapmods/battlegroundmapmods/overwatchdata.stormmod/base.stormdata/libover.galaxy

libover.galaxy
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();
}