LibHLUC.galaxy

include "TriggerLibs/NativeLib"
include "TriggerLibs/HeroesLib"
include "TriggerLibs/GameLib"
include "TriggerLibs/SoundLib"

include "LibHLUC_h"

//--------------------------------------------------------------------------------------------------
// Library: Lucio
//--------------------------------------------------------------------------------------------------
// External Library Initialization
void libHLUC_InitLibraries () {
    libNtve_InitVariables();
    libCore_InitVariables();
    libGame_InitVariables();
    libSond_InitVariables();
}

// Variable Initialization
bool libHLUC_InitVariables_completed = false;

void libHLUC_InitVariables () {
    if (libHLUC_InitVariables_completed) {
        return;
    }

    libHLUC_InitVariables_completed = true;

}

// Functions
void libHLUC_gf_HeroLucioIncrementHeroCountFunction () {
    // Automatic Variable Declarations
    // Implementation
    libHLUC_gv_heroLucioTriggerRegistrationVariable += 1;
    if ((libHLUC_gv_heroLucioTriggerRegistrationVariable == 1)) {
        TriggerEnable(libHLUC_gt_HeroLucioSoundtrackInitialization, true);
        TriggerEnable(libHLUC_gt_HeroLucioHeroWeaponApplyTargetingUnit, true);
        TriggerEnable(libHLUC_gt_HeroLucioTargetAcquired, true);
        TriggerEnable(libHLUC_gt_HeroLucioForceAcquireTargetTaunt, true);
        TriggerEnable(libHLUC_gt_HeroLucioHoldFire, true);
        TriggerEnable(libHLUC_gt_HeroLucioCrossfadeSpeedBoostInitializer, true);
        TriggerEnable(libHLUC_gt_HeroLucioSoundBarrierShieldsCombatText, true);
        TriggerEnable(libHLUC_gt_HeroLucioReverseAmpNonstopRemix, true);
        TriggerEnable(libHLUC_gt_HeroLucioAmpItUpMaximumTempo, true);
        TriggerEnable(libHLUC_gt_HeroLucioBackInTheMix, true);
        TriggerEnable(libHLUC_gt_HeroLucioCantStopWontStop, true);
        TriggerEnable(libHLUC_gt_HeroLucioCrossfadeBoomboxSynaesthesiaAuditiva, true);
        TriggerEnable(libHLUC_gt_HeroLucioGoodVibrationsShieldsCombatText, true);
    }

}

void libHLUC_gf_HeroLucioDecrementHeroCountFunction () {
    // Automatic Variable Declarations
    // Implementation
    libHLUC_gv_heroLucioTriggerRegistrationVariable -= 1;
    if ((libHLUC_gv_heroLucioTriggerRegistrationVariable < 0)) {
        libHLUC_gv_heroLucioTriggerRegistrationVariable = 0;
    }

    if ((libHLUC_gv_heroLucioTriggerRegistrationVariable == 0)) {
        TriggerEnable(libHLUC_gt_HeroLucioSoundtrackInitialization, false);
        TriggerEnable(libHLUC_gt_HeroLucioHeroWeaponApplyTargetingUnit, false);
        TriggerEnable(libHLUC_gt_HeroLucioTargetAcquired, false);
        TriggerEnable(libHLUC_gt_HeroLucioForceAcquireTargetTaunt, false);
        TriggerEnable(libHLUC_gt_HeroLucioHoldFire, false);
        TriggerEnable(libHLUC_gt_HeroLucioCrossfadeSpeedBoostInitializer, false);
        TriggerEnable(libHLUC_gt_HeroLucioSoundBarrierShieldsCombatText, false);
        TriggerEnable(libHLUC_gt_HeroLucioReverseAmpNonstopRemix, false);
        TriggerEnable(libHLUC_gt_HeroLucioAmpItUpMaximumTempo, false);
        TriggerEnable(libHLUC_gt_HeroLucioBackInTheMix, false);
        TriggerEnable(libHLUC_gt_HeroLucioCantStopWontStop, false);
        TriggerEnable(libHLUC_gt_HeroLucioCrossfadeBoomboxSynaesthesiaAuditiva, false);
        TriggerEnable(libHLUC_gt_HeroLucioGoodVibrationsShieldsCombatText, false);
    }

}

trigger auto_libHLUC_gf_SoundtrackPlayMapIntroSoundtrackForAllPlayers_Trigger = null;

void libHLUC_gf_SoundtrackPlayMapIntroSoundtrackForAllPlayers () {
    if (auto_libHLUC_gf_SoundtrackPlayMapIntroSoundtrackForAllPlayers_Trigger == null) {
        auto_libHLUC_gf_SoundtrackPlayMapIntroSoundtrackForAllPlayers_Trigger = TriggerCreate("auto_libHLUC_gf_SoundtrackPlayMapIntroSoundtrackForAllPlayers_TriggerFunc");
    }

    TriggerExecute(auto_libHLUC_gf_SoundtrackPlayMapIntroSoundtrackForAllPlayers_Trigger, false, false);
}

bool auto_libHLUC_gf_SoundtrackPlayMapIntroSoundtrackForAllPlayers_TriggerFunc (bool testConds, bool runActions) {
    // Variable Declarations
    string lv_soundtrack;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    lv_soundtrack = libCore_gv_mAPMapSoundtrack[0];
    if ((lv_soundtrack == null)) {
        return true;
    }

    libSond_gv_soundtrack_MapSoundtrackPlaying = true;
    libSond_gv_soundtrack_IntroSoundtrackPlaying = true;
    SoundtrackPlay(PlayerGroupAll(), c_soundtrackCategoryMusic, lv_soundtrack, c_soundtrackCueAny, c_soundtrackIndexAny, false);
    SoundtrackStop(PlayerGroupAll(), c_soundtrackCategoryMusic, true);
    SoundtrackWait(lv_soundtrack);
    libSond_gf_SoundtrackUpdateMapSoundtrackIndex();
    return true;
}

// Triggers
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Lucio - Soundtrack Initialization
//--------------------------------------------------------------------------------------------------
bool libHLUC_gt_HeroLucioSoundtrackInitialization_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_lucioPlayer;

    // Automatic Variable Declarations
    // Variable Initialization

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

    if ((UnitGetType(libGame_gv_players[libGame_gf_HeroSpawnPlayer()].lv_heroUnit) == "HeroLucio")) {
        lv_lucioPlayer = UnitGetOwner(libGame_gv_players[libGame_gf_HeroSpawnPlayer()].lv_heroUnit);
        SoundtrackStop(PlayerGroupSingle(libGame_gf_HeroSpawnPlayer()), c_soundtrackCategoryMusic, false);
        libSond_gv_soundtrack_UniqueSoundtrackEnabled[lv_lucioPlayer] = true;
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libHLUC_gt_HeroLucioSoundtrackInitialization_Init () {
    libHLUC_gt_HeroLucioSoundtrackInitialization = TriggerCreate("libHLUC_gt_HeroLucioSoundtrackInitialization_Func");
    TriggerEnable(libHLUC_gt_HeroLucioSoundtrackInitialization, false);
    libGame_gf_HeroSpawn(libHLUC_gt_HeroLucioSoundtrackInitialization);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Lucio - Hero Weapon Apply Targeting Unit
//--------------------------------------------------------------------------------------------------
bool libHLUC_gt_HeroLucioHeroWeaponApplyTargetingUnit_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_lucioUnit;
    unit lv_targetUnit;
    point lv_targetPoint;
    int lv_lucioPlayer;
    bool lv_hadHoldFire;
    bool lv_hadDisabler;
    bool lv_hadMountedDisabler;

    // Automatic Variable Declarations
    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((UnitGetType(EventUnit()) == "HeroLucio"))) {
            return false;
        }
    }

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

    lv_lucioUnit = EventUnit();
    lv_lucioPlayer = UnitGetOwner(EventUnit());
    lv_targetUnit = EventUnitTargetUnit();
    if ((lv_targetUnit != null) && (UnitFilterMatch(lv_targetUnit, lv_lucioPlayer, UnitFilter(0, 0, (1 << c_targetFilterPlayer) | (1 << c_targetFilterAlly) | (1 << c_targetFilterMissile) | (1 << c_targetFilterItem), (1 << (c_targetFilterStasis - 32)) | (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterInvulnerable - 32)))) == true)) {
        if ((lv_targetUnit == libHLUC_gv_heroLucioCurrentAttackTarget[lv_lucioPlayer]) && (UnitHasBehavior2(libHLUC_gv_heroLucioCurrentAttackTarget[lv_lucioPlayer], "LucioWeaponTargeting") == true)) {
            return true;
        }

        if ((libHLUC_gv_heroLucioCurrentAttackTarget[lv_lucioPlayer] != null) && (libHLUC_gv_heroLucioCurrentAttackTarget[lv_lucioPlayer] != lv_targetUnit) && (UnitHasBehavior2(libHLUC_gv_heroLucioCurrentAttackTarget[lv_lucioPlayer], "LucioWeaponTargeting") == true)) {
            UnitCreateEffectUnit(lv_lucioUnit, "LucioWeaponRemoveTargetingBehavior", libHLUC_gv_heroLucioCurrentAttackTarget[lv_lucioPlayer]);
        }

        UnitCreateEffectUnit(lv_lucioUnit, "LucioWeaponClearWeaponTargets", lv_lucioUnit);
        UnitCreateEffectUnit(lv_lucioUnit, "LucioWeaponApplyTargetingBehavior", lv_targetUnit);
        libHLUC_gv_heroLucioCurrentAttackTarget[lv_lucioPlayer] = lv_targetUnit;
        UnitBehaviorAdd(lv_lucioUnit, "LucioWeaponCasterTargetFinderDisabler", lv_lucioUnit, 1);
    }
    else {
        if ((EventUnitTargetPoint() != null) && (DistanceBetweenPoints(EventUnitTargetPoint(), UnitGetPosition(lv_lucioUnit)) > 0.0)) {
            if ((UnitHasBehavior2(lv_lucioUnit, "LucioWeaponCasterTargetFinderDisabler") == true)) {
                lv_hadDisabler = true;
                UnitBehaviorRemove(lv_lucioUnit, "LucioWeaponCasterTargetFinderDisabler", 1);
            }

            if ((UnitHasBehavior2(lv_lucioUnit, "HoldFire") == true)) {
                lv_hadHoldFire = true;
                UnitBehaviorAdd(lv_lucioUnit, "LucioHoldFireDisabler", lv_lucioUnit, 1);
            }

            lv_targetPoint = EventUnitTargetPoint();
            while (!((UnitOrder(lv_lucioUnit, 0) != OrderTargetingPoint(AbilityCommand("LucioAttack", 0), lv_targetPoint)))) {
                Wait(0.125, c_timeGame);
            }
            if ((lv_hadDisabler == true)) {
                lv_hadDisabler = false;
                UnitBehaviorAdd(lv_lucioUnit, "LucioWeaponCasterTargetFinderDisabler", lv_lucioUnit, 1);
            }

            if ((lv_hadHoldFire == true)) {
                lv_hadHoldFire = false;
                UnitBehaviorRemove(lv_lucioUnit, "LucioHoldFireDisabler", 1);
            }

        }

    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHLUC_gt_HeroLucioHeroWeaponApplyTargetingUnit_Init () {
    libHLUC_gt_HeroLucioHeroWeaponApplyTargetingUnit = TriggerCreate("libHLUC_gt_HeroLucioHeroWeaponApplyTargetingUnit_Func");
    TriggerEnable(libHLUC_gt_HeroLucioHeroWeaponApplyTargetingUnit, false);
    TriggerAddEventUnitAbility(libHLUC_gt_HeroLucioHeroWeaponApplyTargetingUnit, null, AbilityCommand("LucioSmartTargetingRightClick", 0), c_abilEffectStageApproach, false);
    TriggerAddEventUnitAbility(libHLUC_gt_HeroLucioHeroWeaponApplyTargetingUnit, null, AbilityCommand("LucioSmartTargetingRightClick", 0), c_abilEffectStageCast, false);
    TriggerAddEventUnitAbility(libHLUC_gt_HeroLucioHeroWeaponApplyTargetingUnit, null, AbilityCommand("LucioTargetingAttackClick", 0), c_unitAbilStageExecute, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Lucio - Target Acquired
//--------------------------------------------------------------------------------------------------
bool libHLUC_gt_HeroLucioTargetAcquired_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_targetUnit;
    int lv_lucioPlayer;
    unit lv_lucio;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_targetUnit = EventPlayerEffectUsedUnit(c_effectUnitTarget);
    lv_lucioPlayer = UnitGetOwner(EventPlayerEffectUsedUnit(c_effectUnitCaster));

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

        if (!((lv_targetUnit != libHLUC_gv_heroLucioCurrentAttackTarget[lv_lucioPlayer]))) {
            return false;
        }
    }

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

    lv_lucio = EventPlayerEffectUsedUnit(c_effectUnitCaster);
    if ((libHLUC_gv_heroLucioCurrentAttackTarget[lv_lucioPlayer] != null) && (UnitHasBehavior2(libHLUC_gv_heroLucioCurrentAttackTarget[lv_lucioPlayer], "LucioWeaponTargeting") == true)) {
        UnitCreateEffectUnit(lv_lucio, "LucioWeaponRemoveTargetingBehavior", libHLUC_gv_heroLucioCurrentAttackTarget[lv_lucioPlayer]);
    }

    UnitCreateEffectUnit(lv_lucio, "LucioWeaponCasterTargetApplyDisablerBehavior", lv_lucio);
    libHLUC_gv_heroLucioCurrentAttackTarget[lv_lucioPlayer] = lv_targetUnit;
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHLUC_gt_HeroLucioTargetAcquired_Init () {
    libHLUC_gt_HeroLucioTargetAcquired = TriggerCreate("libHLUC_gt_HeroLucioTargetAcquired_Func");
    TriggerEnable(libHLUC_gt_HeroLucioTargetAcquired, false);
    TriggerAddEventPlayerEffectUsed(libHLUC_gt_HeroLucioTargetAcquired, c_playerAny, "LucioWeaponNewTargetImpactSet");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Lucio - Force Acquire Target (Taunt)
//--------------------------------------------------------------------------------------------------
bool libHLUC_gt_HeroLucioForceAcquireTargetTaunt_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_unittoAttack;
    unit lv_lucioUnit;
    int lv_lucioPlayer;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_unittoAttack = EventPlayerEffectUsedUnit(c_effectUnitCaster);
    lv_lucioUnit = EventPlayerEffectUsedUnit(c_effectUnitTarget);
    lv_lucioPlayer = UnitGetOwner(lv_lucioUnit);

    // Conditions
    if (testConds) {
        if (!((UnitGetType(lv_lucioUnit) == "HeroLucio"))) {
            return false;
        }
    }

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

    UnitIssueOrder(lv_lucioUnit, OrderTargetingUnit(AbilityCommand("LucioSmartTargetingRightClick", 0), lv_unittoAttack), c_orderQueueReplace);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHLUC_gt_HeroLucioForceAcquireTargetTaunt_Init () {
    libHLUC_gt_HeroLucioForceAcquireTargetTaunt = TriggerCreate("libHLUC_gt_HeroLucioForceAcquireTargetTaunt_Func");
    TriggerEnable(libHLUC_gt_HeroLucioForceAcquireTargetTaunt, false);
    TriggerAddEventPlayerEffectUsed(libHLUC_gt_HeroLucioForceAcquireTargetTaunt, c_playerAny, "ForceTargetToAttackCasterUnitScriptDummy");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Lucio - Hold Fire
//--------------------------------------------------------------------------------------------------
bool libHLUC_gt_HeroLucioHoldFire_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_lucio;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_lucio = EventUnit();

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

        if (!((UnitGetType(lv_lucio) == "HeroLucio"))) {
            return false;
        }
    }

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

    UnitBehaviorAdd(lv_lucio, "LucioWeaponDisablerHoldFire", lv_lucio, 1);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHLUC_gt_HeroLucioHoldFire_Init () {
    libHLUC_gt_HeroLucioHoldFire = TriggerCreate("libHLUC_gt_HeroLucioHoldFire_Func");
    TriggerEnable(libHLUC_gt_HeroLucioHoldFire, false);
    TriggerAddEventUnitOrder(libHLUC_gt_HeroLucioHoldFire, null, AbilityCommand("HoldFire", 1));
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Lucio - Crossfade Speed Boost Initializer
//--------------------------------------------------------------------------------------------------
bool libHLUC_gt_HeroLucioCrossfadeSpeedBoostInitializer_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_lucioUnit;

    // Automatic Variable Declarations
    // Variable Initialization

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

    lv_lucioUnit = EventUnit();
    UnitCreateEffectUnit(lv_lucioUnit, "LucioCrossfadeSpeedBoostApplierInitialSet", lv_lucioUnit);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHLUC_gt_HeroLucioCrossfadeSpeedBoostInitializer_Init () {
    libHLUC_gt_HeroLucioCrossfadeSpeedBoostInitializer = TriggerCreate("libHLUC_gt_HeroLucioCrossfadeSpeedBoostInitializer_Func");
    TriggerEnable(libHLUC_gt_HeroLucioCrossfadeSpeedBoostInitializer, false);
    TriggerAddEventUnitBehaviorChange(libHLUC_gt_HeroLucioCrossfadeSpeedBoostInitializer, null, "LucioCrossfadeSpeedBoostApplier", c_unitBehaviorChangeActivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Lucio - Sound Barrier - Shields Combat Text
//--------------------------------------------------------------------------------------------------
bool libHLUC_gt_HeroLucioSoundBarrierShieldsCombatText_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_casterPlayer;
    fixed lv_shieldsToAdd;
    fixed lv_vertOffset;
    fixed lv_horizOffset;

    // Automatic Variable Declarations
    // Variable Initialization

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

    lv_casterPlayer = EventPlayerEffectUsedUnitOwner(c_effectPlayerCaster);
    if ((EventPlayerEffectUsed() == "LucioSoundBarrierShieldApply")) {
        lv_shieldsToAdd = (CatalogFieldValueGetAsFixed(c_gameCatalogEffect, "LucioSoundBarrierShieldApply", "Count", lv_casterPlayer) * CatalogFieldValueGetAsFixed(c_gameCatalogBehavior, "LucioSoundBarrierShield", "DamageResponse.ModifyLimit", lv_casterPlayer));
    }
    else {
        lv_shieldsToAdd = (CatalogFieldValueGetAsFixed(c_gameCatalogEffect, "LucioSoundBarrierBossaNovaShieldApply", "Count", lv_casterPlayer) * CatalogFieldValueGetAsFixed(c_gameCatalogBehavior, "LucioSoundBarrierBossaNovaShield", "DamageResponse.ModifyLimit", lv_casterPlayer));
    }
    lv_vertOffset = 2.0;
    lv_horizOffset = RandomFixed(-0.4, -0.6);
    FloatingCombatElementCreateTextAtUnit(PlayerGroupSingle(lv_casterPlayer), "FloatingCombatElements/FloatingCombatLesserAmountReceived", "ShieldState", EventPlayerEffectUsedUnit(c_effectUnitTarget), FixedToText(lv_shieldsToAdd, 0), libNtve_gv_FloatingCombatTextAutoRandomSeed);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHLUC_gt_HeroLucioSoundBarrierShieldsCombatText_Init () {
    libHLUC_gt_HeroLucioSoundBarrierShieldsCombatText = TriggerCreate("libHLUC_gt_HeroLucioSoundBarrierShieldsCombatText_Func");
    TriggerEnable(libHLUC_gt_HeroLucioSoundBarrierShieldsCombatText, false);
    TriggerAddEventPlayerEffectUsed(libHLUC_gt_HeroLucioSoundBarrierShieldsCombatText, c_playerAny, "LucioSoundBarrierShieldApply");
    TriggerAddEventPlayerEffectUsed(libHLUC_gt_HeroLucioSoundBarrierShieldsCombatText, c_playerAny, "LucioSoundBarrierBossaNovaShieldApply");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Lucio - Reverse - Amp Nonstop Remix
//--------------------------------------------------------------------------------------------------
bool libHLUC_gt_HeroLucioReverseAmpNonstopRemix_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_lucioUnit;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_lucioUnit = EventUnit();

    // Conditions
    if (testConds) {
        if (!((PlayerHasTalent(EventPlayer(), "LucioReverseAmpNonstopRemix") == true))) {
            return false;
        }
    }

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

    while ((UnitHasBehavior2(lv_lucioUnit, "LucioReverseAmp") == true)) {
        if ((UnitBehaviorCount(lv_lucioUnit, "LucioReverseAmpNonstopRemixToken") >= 2)) {
            UnitBehaviorSetDurationRemaining(lv_lucioUnit, "LucioReverseAmp", (UnitBehaviorDuration(lv_lucioUnit, "LucioReverseAmp") + 0.0625));
        }

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

//--------------------------------------------------------------------------------------------------
void libHLUC_gt_HeroLucioReverseAmpNonstopRemix_Init () {
    libHLUC_gt_HeroLucioReverseAmpNonstopRemix = TriggerCreate("libHLUC_gt_HeroLucioReverseAmpNonstopRemix_Func");
    TriggerEnable(libHLUC_gt_HeroLucioReverseAmpNonstopRemix, false);
    TriggerAddEventUnitBehaviorChange(libHLUC_gt_HeroLucioReverseAmpNonstopRemix, null, "LucioReverseAmp", c_unitBehaviorChangeCreate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Lucio - Amp It Up - Maximum Tempo
//--------------------------------------------------------------------------------------------------
bool libHLUC_gt_HeroLucioAmpItUpMaximumTempo_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_player;
    unit lv_lucio;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_player = libGame_gf_HeroParticipatedInTakedownKillingPlayer();

    // Conditions
    if (testConds) {
        if (!((UnitGetType(libGame_gv_players[lv_player].lv_heroUnit) == "HeroLucio"))) {
            return false;
        }

        if (!((PlayerHasTalent(lv_player, "LucioAmpItUpMaximumTempoQuest") == true))) {
            return false;
        }
    }

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

    lv_lucio = libGame_gv_players[lv_player].lv_heroUnit;
    if ((UnitIsAlive(lv_lucio) == true) && (UnitHasBehavior2(lv_lucio, "LucioCrossfadeSpeedBoost") == true)) {
        UnitCreateEffectUnit(lv_lucio, "LucioAmpItUpMaximumTempoModifyQuestToken", lv_lucio);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libHLUC_gt_HeroLucioAmpItUpMaximumTempo_Init () {
    libHLUC_gt_HeroLucioAmpItUpMaximumTempo = TriggerCreate("libHLUC_gt_HeroLucioAmpItUpMaximumTempo_Func");
    TriggerEnable(libHLUC_gt_HeroLucioAmpItUpMaximumTempo, false);
    libGame_gf_HeroParticipatedInTakedown(libHLUC_gt_HeroLucioAmpItUpMaximumTempo);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Lucio - Back In The Mix
//--------------------------------------------------------------------------------------------------
bool libHLUC_gt_HeroLucioBackInTheMix_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_lucioUnit;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_lucioUnit = EventUnit();

    // Conditions
    if (testConds) {
        if (!((UnitGetType(lv_lucioUnit) == "HeroLucio"))) {
            return false;
        }

        if (!((PlayerHasTalent(UnitGetOwner(lv_lucioUnit), "LucioBackInTheMix") == true))) {
            return false;
        }

        if (!((UnitHasBehavior2(lv_lucioUnit, "LucioBackInTheMixDisabler") == false))) {
            return false;
        }

        if (!((((UnitHasBehaviorWithCategoryFlag(lv_lucioUnit, c_behaviorCategoryBuffUnstoppable) == false) && (UnitHasBehaviorWithCategoryFlag(lv_lucioUnit, c_behaviorCategoryInvulnerable) == false)) || ((UnitHasBehaviorWithCategoryFlag(lv_lucioUnit, c_behaviorCategoryBuffUnstoppable) == true) && (UnitHasBehaviorWithCategoryFlag(lv_lucioUnit, c_behaviorCategoryTimeStop) == true)) || ((UnitHasBehaviorWithCategoryFlag(lv_lucioUnit, c_behaviorCategoryInvulnerable) == true) && (UnitHasBehaviorWithCategoryFlag(lv_lucioUnit, c_behaviorCategoryTimeStop) == true))))) {
            return false;
        }
    }

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

    UnitBehaviorAdd(lv_lucioUnit, "LucioBackInTheMixDisabler", lv_lucioUnit, 1);
    UnitCreateEffectUnit(lv_lucioUnit, "LucioBackInTheMixHeal", lv_lucioUnit);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHLUC_gt_HeroLucioBackInTheMix_Init () {
    libHLUC_gt_HeroLucioBackInTheMix = TriggerCreate("libHLUC_gt_HeroLucioBackInTheMix_Func");
    TriggerEnable(libHLUC_gt_HeroLucioBackInTheMix, false);
    TriggerAddEventUnitBehaviorChangeFromCategory(libHLUC_gt_HeroLucioBackInTheMix, null, c_behaviorCategoryStun, c_unitBehaviorChangeCreate);
    TriggerAddEventUnitBehaviorChangeFromCategory(libHLUC_gt_HeroLucioBackInTheMix, null, c_behaviorCategoryStun, c_unitBehaviorChangeRefresh);
    TriggerAddEventUnitBehaviorChangeFromCategory(libHLUC_gt_HeroLucioBackInTheMix, null, c_behaviorCategoryTimeStop, c_unitBehaviorChangeCreate);
    TriggerAddEventUnitBehaviorChangeFromCategory(libHLUC_gt_HeroLucioBackInTheMix, null, c_behaviorCategoryTimeStop, c_unitBehaviorChangeRefresh);
    TriggerAddEventUnitBehaviorChangeFromCategory(libHLUC_gt_HeroLucioBackInTheMix, null, c_behaviorCategoryDebuffSilence, c_unitBehaviorChangeCreate);
    TriggerAddEventUnitBehaviorChangeFromCategory(libHLUC_gt_HeroLucioBackInTheMix, null, c_behaviorCategoryDebuffSilence, c_unitBehaviorChangeRefresh);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Lucio - Can't Stop, Won't Stop
//--------------------------------------------------------------------------------------------------
bool libHLUC_gt_HeroLucioCantStopWontStop_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_lucioUnit;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_lucioUnit = EventUnit();

    // Conditions
    if (testConds) {
        if (!((UnitGetType(lv_lucioUnit) == "HeroLucio"))) {
            return false;
        }

        if (!((PlayerHasTalent(UnitGetOwner(lv_lucioUnit), "LucioWallRideCantStopWontStop") == true))) {
            return false;
        }

        if (!((UnitHasBehavior2(lv_lucioUnit, "LucioWallRideSpeed") == true))) {
            return false;
        }
    }

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

    ActorCreate(ActorScopeFromUnit(lv_lucioUnit), "LucioWallRideCantStopWontStopActivate", null, null, null);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHLUC_gt_HeroLucioCantStopWontStop_Init () {
    libHLUC_gt_HeroLucioCantStopWontStop = TriggerCreate("libHLUC_gt_HeroLucioCantStopWontStop_Func");
    TriggerEnable(libHLUC_gt_HeroLucioCantStopWontStop, false);
    TriggerAddEventUnitBehaviorChangeFromCategory(libHLUC_gt_HeroLucioCantStopWontStop, null, c_behaviorCategorySlow, c_unitBehaviorChangeCreate);
    TriggerAddEventUnitBehaviorChangeFromCategory(libHLUC_gt_HeroLucioCantStopWontStop, null, c_behaviorCategoryDebuffRoot, c_unitBehaviorChangeCreate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Lucio - Crossfade Boombox Synaesthesia Auditiva
//--------------------------------------------------------------------------------------------------
bool libHLUC_gt_HeroLucioCrossfadeBoomboxSynaesthesiaAuditiva_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_boomboxUnit;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_boomboxUnit = EventUnit();

    // Conditions
    if (testConds) {
        if (!((PlayerHasTalent(UnitGetOwner(lv_boomboxUnit), "LucioAmpItUpSynaesthesiaAuditiva") == true))) {
            return false;
        }

        if (!((UnitHasBehavior2(libGame_gv_players[UnitGetOwner(lv_boomboxUnit)].lv_heroUnit, "LucioAmpItUpSynaesthesiaAuditivaCastTracker") == true))) {
            return false;
        }
    }

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

    UnitCreateEffectUnit(lv_boomboxUnit, "LucioAmpItUpSynaesthesiaAuditivaSearchArea", lv_boomboxUnit);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHLUC_gt_HeroLucioCrossfadeBoomboxSynaesthesiaAuditiva_Init () {
    libHLUC_gt_HeroLucioCrossfadeBoomboxSynaesthesiaAuditiva = TriggerCreate("libHLUC_gt_HeroLucioCrossfadeBoomboxSynaesthesiaAuditiva_Func");
    TriggerEnable(libHLUC_gt_HeroLucioCrossfadeBoomboxSynaesthesiaAuditiva, false);
    TriggerAddEventUnitBehaviorChange(libHLUC_gt_HeroLucioCrossfadeBoomboxSynaesthesiaAuditiva, null, "LucioBoomboxAmpItUpDetector", c_unitBehaviorChangeActivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Lucio - Good Vibrations - Shields Combat Text
//--------------------------------------------------------------------------------------------------
bool libHLUC_gt_HeroLucioGoodVibrationsShieldsCombatText_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_casterPlayer;
    fixed lv_shieldsToAdd;
    fixed lv_vertOffset;
    fixed lv_horizOffset;

    // Automatic Variable Declarations
    // Variable Initialization

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

    lv_casterPlayer = EventPlayerEffectUsedUnitOwner(c_effectPlayerCaster);
    if ((EventPlayerEffectUsed() == "LucioSoundwaveGoodVibrationsApplyShieldBehaviorHero")) {
        lv_shieldsToAdd = (CatalogFieldValueGetAsFixed(c_gameCatalogEffect, "LucioSoundwaveGoodVibrationsApplyShieldBehaviorHero", "Count", lv_casterPlayer) * CatalogFieldValueGetAsFixed(c_gameCatalogBehavior, "LucioSoundwaveGoodVibrationsShield", "DamageResponse.ModifyLimit", lv_casterPlayer));
    }
    else {
        lv_shieldsToAdd = (CatalogFieldValueGetAsFixed(c_gameCatalogEffect, "LucioSoundwaveGoodVibrationsApplyShieldBehavior", "Count", lv_casterPlayer) * CatalogFieldValueGetAsFixed(c_gameCatalogBehavior, "LucioSoundwaveGoodVibrationsShield", "DamageResponse.ModifyLimit", lv_casterPlayer));
    }
    lv_vertOffset = 2.0;
    lv_horizOffset = RandomFixed(-0.4, -0.6);
    FloatingCombatElementCreateTextAtUnit(PlayerGroupSingle(lv_casterPlayer), "FloatingCombatElements/FloatingCombatLesserAmountReceived", "ShieldState", EventPlayerEffectUsedUnit(c_effectUnitTarget), FixedToText(lv_shieldsToAdd, 0), libNtve_gv_FloatingCombatTextAutoRandomSeed);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHLUC_gt_HeroLucioGoodVibrationsShieldsCombatText_Init () {
    libHLUC_gt_HeroLucioGoodVibrationsShieldsCombatText = TriggerCreate("libHLUC_gt_HeroLucioGoodVibrationsShieldsCombatText_Func");
    TriggerEnable(libHLUC_gt_HeroLucioGoodVibrationsShieldsCombatText, false);
    TriggerAddEventPlayerEffectUsed(libHLUC_gt_HeroLucioGoodVibrationsShieldsCombatText, c_playerAny, "LucioSoundwaveGoodVibrationsApplyShieldBehaviorHero");
    TriggerAddEventPlayerEffectUsed(libHLUC_gt_HeroLucioGoodVibrationsShieldsCombatText, c_playerAny, "LucioSoundwaveGoodVibrationsApplyShieldBehavior");
}

void libHLUC_InitTriggers () {
    libHLUC_gt_HeroLucioSoundtrackInitialization_Init();
    libHLUC_gt_HeroLucioHeroWeaponApplyTargetingUnit_Init();
    libHLUC_gt_HeroLucioTargetAcquired_Init();
    libHLUC_gt_HeroLucioForceAcquireTargetTaunt_Init();
    libHLUC_gt_HeroLucioHoldFire_Init();
    libHLUC_gt_HeroLucioCrossfadeSpeedBoostInitializer_Init();
    libHLUC_gt_HeroLucioSoundBarrierShieldsCombatText_Init();
    libHLUC_gt_HeroLucioReverseAmpNonstopRemix_Init();
    libHLUC_gt_HeroLucioAmpItUpMaximumTempo_Init();
    libHLUC_gt_HeroLucioBackInTheMix_Init();
    libHLUC_gt_HeroLucioCantStopWontStop_Init();
    libHLUC_gt_HeroLucioCrossfadeBoomboxSynaesthesiaAuditiva_Init();
    libHLUC_gt_HeroLucioGoodVibrationsShieldsCombatText_Init();
}

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

void libHLUC_InitLib () {
    if (libHLUC_InitLib_completed) {
        return;
    }

    libHLUC_InitLib_completed = true;

    libHLUC_InitLibraries();
    libHLUC_InitVariables();
    libHLUC_InitTriggers();
}