PTR build 2.57.1.98674_ptr. Go to the live site.

mods/heromods/firebat.stormmod/base.stormdata/libhfir.galaxy

libhfir.galaxy
include "TriggerLibs/NativeLib"
include "TriggerLibs/HeroesLib"
include "TriggerLibs/GameLib"
include "TriggerLibs/AILib"
include "TriggerLibs/UILib"

include "LibHFIR_h"

//--------------------------------------------------------------------------------------------------
// Library: Firebat
//--------------------------------------------------------------------------------------------------
// External Library Initialization
void libHFIR_InitLibraries () {
    libNtve_InitVariables();
    libCore_InitVariables();
    libGame_InitVariables();
    libAIAI_InitVariables();
    libUIUI_InitVariables();
}

// Variable Initialization
bool libHFIR_InitVariables_completed = false;

void libHFIR_InitVariables () {
    int init_i;

    if (libHFIR_InitVariables_completed) {
        return;
    }

    libHFIR_InitVariables_completed = true;

    for (init_i = 0; init_i <= libCore_gv_bALMaxPlayers; init_i += 1) {
        libHFIR_gv_bunkerOverlayFX_Timer[init_i] = TimerCreate();
    }
}

// Functions
void libHFIR_gf_HeroFirebatIncrementHeroCountFunction () {
    // Automatic Variable Declarations
    // Implementation
    libHFIR_gv_heroFirebatTriggerRegistrationVariable += 1;
    if ((libHFIR_gv_heroFirebatTriggerRegistrationVariable == 1)) {
        TriggerEnable(libHFIR_gt_HeroFirebatBunkerDropTurretUnitSelect, true);
        TriggerEnable(libHFIR_gt_HeroFirebatBunkerDropTurretUnitDeselect, true);
        TriggerEnable(libHFIR_gt_HeroFirebatBunkerDropOverlayOn, true);
        TriggerEnable(libHFIR_gt_HeroFirebatBunkerDropOverlayOff, true);
        TriggerEnable(libHFIR_gt_HeroFirebatBunkerDropOverlayFlamethrowerFXStart, true);
        TriggerEnable(libHFIR_gt_HeroFirebatBunkerDropOverlayFlamethrowerFXEnd, true);
        TriggerEnable(libHFIR_gt_HeroFirebatJuggernautPlatingDamageTracker, true);
        TriggerEnable(libHFIR_gt_HeroFirebatJuggernautPlatingApplyShield, true);
        TriggerEnable(libHFIR_gt_HeroFirebatBunkerDropFortifiedBunkerOilSpillCast, true);
        TriggerEnable(libHFIR_gt_HeroFirebatBunkerDropFlamethrowerReveal, true);
        TriggerEnable(libHFIR_gt_HeroFirebatBunkerDropEnterTurnAIOn, true);
    }

}

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

    if ((libHFIR_gv_heroFirebatTriggerRegistrationVariable == 0)) {
        TriggerEnable(libHFIR_gt_HeroFirebatBunkerDropTurretUnitSelect, false);
        TriggerEnable(libHFIR_gt_HeroFirebatBunkerDropTurretUnitDeselect, false);
        TriggerEnable(libHFIR_gt_HeroFirebatBunkerDropOverlayOn, false);
        TriggerEnable(libHFIR_gt_HeroFirebatBunkerDropOverlayOff, false);
        TriggerEnable(libHFIR_gt_HeroFirebatBunkerDropOverlayFlamethrowerFXStart, false);
        TriggerEnable(libHFIR_gt_HeroFirebatBunkerDropOverlayFlamethrowerFXEnd, false);
        TriggerEnable(libHFIR_gt_HeroFirebatJuggernautPlatingDamageTracker, false);
        TriggerEnable(libHFIR_gt_HeroFirebatJuggernautPlatingApplyShield, false);
        TriggerEnable(libHFIR_gt_HeroFirebatBunkerDropFortifiedBunkerOilSpillCast, false);
        TriggerEnable(libHFIR_gt_HeroFirebatBunkerDropFlamethrowerReveal, false);
        TriggerEnable(libHFIR_gt_HeroFirebatBunkerDropEnterTurnAIOn, false);
    }

}

// Triggers
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Firebat - Bunker Drop - Fortified Bunker - Oil Spill Cast
//--------------------------------------------------------------------------------------------------
bool libHFIR_gt_HeroFirebatBunkerDropFortifiedBunkerOilSpillCast_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_firebatPlayer;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_firebatPlayer = EventPlayerEffectUsedUnitOwner(c_effectPlayerCaster);

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

    UnitCreateEffectUnit(libGame_gv_players[lv_firebatPlayer].lv_heroUnit, "FirebatOilSpillTrackerAddCaster", EventPlayerEffectUsedUnit(c_effectUnitTarget));
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHFIR_gt_HeroFirebatBunkerDropFortifiedBunkerOilSpillCast_Init () {
    libHFIR_gt_HeroFirebatBunkerDropFortifiedBunkerOilSpillCast = TriggerCreate("libHFIR_gt_HeroFirebatBunkerDropFortifiedBunkerOilSpillCast_Func");
    TriggerEnable(libHFIR_gt_HeroFirebatBunkerDropFortifiedBunkerOilSpillCast, false);
    TriggerAddEventPlayerEffectUsed(libHFIR_gt_HeroFirebatBunkerDropFortifiedBunkerOilSpillCast, c_playerAny, "FirebatOilSpillDummySpawnSet");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Firebat - Bunker Drop - Flamethrower  - Reveal
//--------------------------------------------------------------------------------------------------
bool libHFIR_gt_HeroFirebatBunkerDropFlamethrowerReveal_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_flamethrowerUnit;
    unit lv_impactUnit;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_flamethrowerUnit = EventPlayerEffectUsedUnit(c_effectUnitCaster);
    lv_impactUnit = EventPlayerEffectUsedUnit(c_effectUnitTarget);

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

    UnitCreateEffectPoint(lv_impactUnit, "FirebatBunkerDropFlamethrowerCreatePersistentReveal", UnitGetPosition(lv_flamethrowerUnit));
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHFIR_gt_HeroFirebatBunkerDropFlamethrowerReveal_Init () {
    libHFIR_gt_HeroFirebatBunkerDropFlamethrowerReveal = TriggerCreate("libHFIR_gt_HeroFirebatBunkerDropFlamethrowerReveal_Func");
    TriggerEnable(libHFIR_gt_HeroFirebatBunkerDropFlamethrowerReveal, false);
    TriggerAddEventPlayerEffectUsed(libHFIR_gt_HeroFirebatBunkerDropFlamethrowerReveal, c_playerAny, "FirebatBunkerDropFlamethrowerImpactSet");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Firebat - Bunker Drop - Turret - Unit Select
//--------------------------------------------------------------------------------------------------
bool libHFIR_gt_HeroFirebatBunkerDropTurretUnitSelect_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_bunkerDropTurretUnit;
    unit lv_bunkerDropPassengerUnit;
    int lv_bunkerDropPassengerPlayer;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_bunkerDropTurretUnit = EventPlayerEffectUsedUnit(c_effectUnitTarget);
    lv_bunkerDropPassengerUnit = EventPlayerEffectUsedUnit(c_effectUnitCaster);
    lv_bunkerDropPassengerPlayer = UnitGetOwner(lv_bunkerDropTurretUnit);

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

    UnitSetPosition(lv_bunkerDropPassengerUnit, UnitGetPosition(lv_bunkerDropTurretUnit), false);
    UnitAbilityAddCooldown(lv_bunkerDropTurretUnit, "FirebatBunkerDropExitBunker", "Abil/FirebatBunkerDropExitBunker", 0.5);
    libGame_gf_UnitSelectionEnterVehicle(lv_bunkerDropTurretUnit, lv_bunkerDropPassengerUnit, lv_bunkerDropPassengerPlayer);
    libGame_gf_SendInstantEventPlayerEnteredVehicle(lv_bunkerDropPassengerPlayer, lv_bunkerDropPassengerUnit, lv_bunkerDropPassengerUnit, lv_bunkerDropTurretUnit);
    if ((libAIAI_gf_HeroAIIsAIEnabledForPlayer(lv_bunkerDropPassengerPlayer) == true)) {
        UnitCreateAIThinkTree(lv_bunkerDropTurretUnit);
    }

    UnitBehaviorAdd(lv_bunkerDropTurretUnit, "DisableAIGoalAssignment", lv_bunkerDropTurretUnit, 1);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHFIR_gt_HeroFirebatBunkerDropTurretUnitSelect_Init () {
    libHFIR_gt_HeroFirebatBunkerDropTurretUnitSelect = TriggerCreate("libHFIR_gt_HeroFirebatBunkerDropTurretUnitSelect_Func");
    TriggerEnable(libHFIR_gt_HeroFirebatBunkerDropTurretUnitSelect, false);
    TriggerAddEventPlayerEffectUsed(libHFIR_gt_HeroFirebatBunkerDropTurretUnitSelect, c_playerAny, "FirebatBunkerDropTurretApplyTimedLifeBehavior");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Firebat - Bunker Drop - Enter Turn AI On
//--------------------------------------------------------------------------------------------------
bool libHFIR_gt_HeroFirebatBunkerDropEnterTurnAIOn_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_bunkerDropTurretUnit;
    int lv_bunkerDropPassengerPlayer;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_bunkerDropTurretUnit = EventPlayerEffectUsedUnit(c_effectUnitTarget);
    lv_bunkerDropPassengerPlayer = UnitGetOwner(lv_bunkerDropTurretUnit);

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

    if ((libAIAI_gf_HeroAIIsAIEnabledForPlayer(lv_bunkerDropPassengerPlayer) == true)) {
        UnitCreateAIThinkTree(lv_bunkerDropTurretUnit);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libHFIR_gt_HeroFirebatBunkerDropEnterTurnAIOn_Init () {
    libHFIR_gt_HeroFirebatBunkerDropEnterTurnAIOn = TriggerCreate("libHFIR_gt_HeroFirebatBunkerDropEnterTurnAIOn_Func");
    TriggerEnable(libHFIR_gt_HeroFirebatBunkerDropEnterTurnAIOn, false);
    TriggerAddEventPlayerEffectUsed(libHFIR_gt_HeroFirebatBunkerDropEnterTurnAIOn, c_playerAny, "FirebatBunkerDropTurretCreateUnitSpawnSet");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Firebat - Bunker Drop - Turret - Unit Deselect
//--------------------------------------------------------------------------------------------------
bool libHFIR_gt_HeroFirebatBunkerDropTurretUnitDeselect_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_bunkerDropTurretUnit;
    unit lv_bunkerDropPassengerUnit;
    unit lv_bunkerDropNoUnit;
    int lv_bunkerDropPassengerPlayer;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_bunkerDropTurretUnit = EventPlayerEffectUsedUnit(c_effectUnitTarget);
    lv_bunkerDropPassengerUnit = EventPlayerEffectUsedUnit(c_effectUnitCaster);
    lv_bunkerDropPassengerPlayer = UnitGetOwner(lv_bunkerDropPassengerUnit);

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

    UnitSelect(lv_bunkerDropTurretUnit, lv_bunkerDropPassengerPlayer, false);
    UnitSelect(lv_bunkerDropPassengerUnit, lv_bunkerDropPassengerPlayer, true);
    UnitBehaviorRemove(lv_bunkerDropPassengerUnit, "HeroGenericTimeStopListener", 1);
    if ((libGame_gv_players[lv_bunkerDropPassengerPlayer].lv_cameraPlayerUnitGroupToFocusOn == libNtve_gf_ConvertUnitToUnitGroup(lv_bunkerDropTurretUnit))) {
        libGame_gv_players[lv_bunkerDropPassengerPlayer].lv_cameraPlayerUnitGroupToFocusOn = libNtve_gf_ConvertUnitToUnitGroup(lv_bunkerDropPassengerUnit);
        libGame_gf_CameraUpdateCameraForPlayer(lv_bunkerDropPassengerPlayer);
    }

    if ((PlayerHero(lv_bunkerDropPassengerPlayer) == "LostVikings")) {
        libGame_gf_ControlGroupsExitVehicleLostVikings(lv_bunkerDropTurretUnit, lv_bunkerDropPassengerUnit, lv_bunkerDropPassengerPlayer);
    }

    if ((PlayerHero(lv_bunkerDropPassengerPlayer) == "Samuro") && (PlayerHasTalent(lv_bunkerDropPassengerPlayer, "SamuroHeroicAbilityIllusionMaster") == true)) {
        libGame_gf_ControlGroupsExitVehicleSamuro(lv_bunkerDropTurretUnit, lv_bunkerDropPassengerUnit, lv_bunkerDropPassengerPlayer);
    }

    libGame_gv_players[lv_bunkerDropPassengerPlayer].lv_cameraPlayerUnitGroupToFocusOn = libNtve_gf_ConvertUnitToUnitGroup(lv_bunkerDropPassengerUnit);
    libGame_gf_CameraUpdateCameraForPlayer(lv_bunkerDropPassengerPlayer);
    libGame_gf_SendInstantEventUnitStopsOccupyingVehicle(lv_bunkerDropPassengerPlayer, lv_bunkerDropPassengerUnit, lv_bunkerDropNoUnit);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHFIR_gt_HeroFirebatBunkerDropTurretUnitDeselect_Init () {
    libHFIR_gt_HeroFirebatBunkerDropTurretUnitDeselect = TriggerCreate("libHFIR_gt_HeroFirebatBunkerDropTurretUnitDeselect_Func");
    TriggerEnable(libHFIR_gt_HeroFirebatBunkerDropTurretUnitDeselect, false);
    TriggerAddEventPlayerEffectUsed(libHFIR_gt_HeroFirebatBunkerDropTurretUnitDeselect, c_playerAny, "FirebatBunkerDropTurretDummyFinalModifyUnit");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Firebat - Bunker Drop - Overlay On
//--------------------------------------------------------------------------------------------------
bool libHFIR_gt_HeroFirebatBunkerDropOverlayOn_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_unit;
    int lv_player;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_unit = EventUnit();
    lv_player = UnitGetOwner(lv_unit);

    // Conditions
    if (testConds) {
        if (!((UnitTestState(lv_unit, c_unitStateHallucination) == false))) {
            return false;
        }
    }

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

    libUIUI_gf_UIDamageFlashStopLowHPSoundAndScreenEffects(lv_player);
    libUIUI_gf_FullscreenOverlayStopandClearCutsceneQueueForPlayer(lv_player);
    libNtve_gf_SetDialogItemCutscene(libUIUI_gv_cargoOverlay.lv_cargoOverlay_Cutscene[lv_player], "Cutscenes\\GameUI_FirebatBunkerOverlay.StormCutscene", PlayerGroupAll());
    DialogControlSendAnimationEvent(libUIUI_gv_cargoOverlay.lv_cargoOverlay_Cutscene[lv_player], libCore_gv_playerGroupFromPlayer[lv_player], "Start");
    DialogControlSetVisible(libUIUI_gv_cargoOverlay.lv_cargoOverlay_Cutscene[lv_player], PlayerGroupSingle(lv_player), true);
    DialogControlSetVisible(libUIUI_gv_cargoOverlay.lv_cargoOverlay[lv_player], PlayerGroupSingle(lv_player), true);
    while ((UnitHasBehavior2(lv_unit, "FirebatBunkerDropPassengerUnitInsideBunker") == true)) {
        Wait(0.0625, c_timeGame);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHFIR_gt_HeroFirebatBunkerDropOverlayOn_Init () {
    libHFIR_gt_HeroFirebatBunkerDropOverlayOn = TriggerCreate("libHFIR_gt_HeroFirebatBunkerDropOverlayOn_Func");
    TriggerEnable(libHFIR_gt_HeroFirebatBunkerDropOverlayOn, false);
    TriggerAddEventUnitBehaviorChange(libHFIR_gt_HeroFirebatBunkerDropOverlayOn, null, "FirebatBunkerDropPassengerUnitInsideBunker", c_unitBehaviorChangeActivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Firebat - Bunker Drop - Overlay Off
//--------------------------------------------------------------------------------------------------
bool libHFIR_gt_HeroFirebatBunkerDropOverlayOff_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_unit;
    int lv_player;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_unit = EventUnit();
    lv_player = UnitGetOwner(lv_unit);

    // Conditions
    if (testConds) {
        if (!((UnitTestState(EventUnit(), c_unitStateHallucination) == false))) {
            return false;
        }
    }

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

    DialogControlSetVisible(libUIUI_gv_cargoOverlay.lv_cargoOverlay_Cutscene[lv_player], PlayerGroupSingle(lv_player), false);
    DialogControlSendAnimationEvent(libUIUI_gv_cargoOverlay.lv_cargoOverlay_Cutscene[lv_player], libCore_gv_playerGroupFromPlayer[lv_player], "Stop");
    if ((UnitGetType(libGame_gv_players[lv_player].lv_heroUnit) != "HeroLostVikingsController")) {
        libGame_gf_CameraPanCameraForPlayerAndUpdateMapBoundsIfNecessary(lv_player, UnitGetPosition(lv_unit), 0.0, -1, 0.0, false);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libHFIR_gt_HeroFirebatBunkerDropOverlayOff_Init () {
    libHFIR_gt_HeroFirebatBunkerDropOverlayOff = TriggerCreate("libHFIR_gt_HeroFirebatBunkerDropOverlayOff_Func");
    TriggerEnable(libHFIR_gt_HeroFirebatBunkerDropOverlayOff, false);
    TriggerAddEventUnitBehaviorChange(libHFIR_gt_HeroFirebatBunkerDropOverlayOff, null, "FirebatBunkerDropPassengerUnitInsideBunker", c_unitBehaviorChangeDeactivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Firebat - Bunker Drop - Overlay Flamethrower FX - Start
//--------------------------------------------------------------------------------------------------
bool libHFIR_gt_HeroFirebatBunkerDropOverlayFlamethrowerFXStart_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_triggeringPlayer;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_triggeringPlayer = EventPlayer();

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

    CutsceneSetFilter(CutsceneGetTriggerControl(libUIUI_gv_cargoOverlay.lv_cargoOverlay_Cutscene[lv_triggeringPlayer]), "Active");
    TimerStart(libHFIR_gv_bunkerOverlayFX_Timer[lv_triggeringPlayer], 2.5, false, c_timeGame);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHFIR_gt_HeroFirebatBunkerDropOverlayFlamethrowerFXStart_Init () {
    libHFIR_gt_HeroFirebatBunkerDropOverlayFlamethrowerFXStart = TriggerCreate("libHFIR_gt_HeroFirebatBunkerDropOverlayFlamethrowerFXStart_Func");
    TriggerEnable(libHFIR_gt_HeroFirebatBunkerDropOverlayFlamethrowerFXStart, false);
    TriggerAddEventUnitAbility(libHFIR_gt_HeroFirebatBunkerDropOverlayFlamethrowerFXStart, null, AbilityCommand("FirebatBunkerDropFlamethrower", 0), c_unitAbilStageAll, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Firebat - Bunker Drop - Overlay Flamethrower FX - End
//--------------------------------------------------------------------------------------------------
bool libHFIR_gt_HeroFirebatBunkerDropOverlayFlamethrowerFXEnd_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    const int autoEA69F6C3_ae = libCore_gv_bALMaxPlayers;
    int autoEA69F6C3_var;

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

    autoEA69F6C3_var = 1;
    for ( ; autoEA69F6C3_var <= autoEA69F6C3_ae; autoEA69F6C3_var += 1 ) {
        if ((EventTimer() == libHFIR_gv_bunkerOverlayFX_Timer[autoEA69F6C3_var])) {
            CutsceneClearFilters(CutsceneGetTriggerControl(libUIUI_gv_cargoOverlay.lv_cargoOverlay_Cutscene[autoEA69F6C3_var]));
            return true;
        }

    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHFIR_gt_HeroFirebatBunkerDropOverlayFlamethrowerFXEnd_Init () {
    libHFIR_gt_HeroFirebatBunkerDropOverlayFlamethrowerFXEnd = TriggerCreate("libHFIR_gt_HeroFirebatBunkerDropOverlayFlamethrowerFXEnd_Func");
    TriggerEnable(libHFIR_gt_HeroFirebatBunkerDropOverlayFlamethrowerFXEnd, false);
    TriggerAddEventTimer(libHFIR_gt_HeroFirebatBunkerDropOverlayFlamethrowerFXEnd, libHFIR_gv_bunkerOverlayFX_Timer[1]);
    TriggerAddEventTimer(libHFIR_gt_HeroFirebatBunkerDropOverlayFlamethrowerFXEnd, libHFIR_gv_bunkerOverlayFX_Timer[2]);
    TriggerAddEventTimer(libHFIR_gt_HeroFirebatBunkerDropOverlayFlamethrowerFXEnd, libHFIR_gv_bunkerOverlayFX_Timer[3]);
    TriggerAddEventTimer(libHFIR_gt_HeroFirebatBunkerDropOverlayFlamethrowerFXEnd, libHFIR_gv_bunkerOverlayFX_Timer[4]);
    TriggerAddEventTimer(libHFIR_gt_HeroFirebatBunkerDropOverlayFlamethrowerFXEnd, libHFIR_gv_bunkerOverlayFX_Timer[5]);
    TriggerAddEventTimer(libHFIR_gt_HeroFirebatBunkerDropOverlayFlamethrowerFXEnd, libHFIR_gv_bunkerOverlayFX_Timer[6]);
    TriggerAddEventTimer(libHFIR_gt_HeroFirebatBunkerDropOverlayFlamethrowerFXEnd, libHFIR_gv_bunkerOverlayFX_Timer[7]);
    TriggerAddEventTimer(libHFIR_gt_HeroFirebatBunkerDropOverlayFlamethrowerFXEnd, libHFIR_gv_bunkerOverlayFX_Timer[8]);
    TriggerAddEventTimer(libHFIR_gt_HeroFirebatBunkerDropOverlayFlamethrowerFXEnd, libHFIR_gv_bunkerOverlayFX_Timer[9]);
    TriggerAddEventTimer(libHFIR_gt_HeroFirebatBunkerDropOverlayFlamethrowerFXEnd, libHFIR_gv_bunkerOverlayFX_Timer[10]);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Firebat - Juggernaut Plating - Damage Tracker
//--------------------------------------------------------------------------------------------------
bool libHFIR_gt_HeroFirebatJuggernautPlatingDamageTracker_Func (bool testConds, bool runActions) {
    // Variable Declarations
    fixed lv_damageAmount;
    unit lv_firebatUnit;
    int lv_firebatPlayer;

    // Automatic Variable Declarations
    // Variable Initialization

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

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

    lv_firebatUnit = EventUnit();
    lv_firebatPlayer = UnitGetOwner(lv_firebatUnit);
    if (((lv_firebatPlayer > libCore_gv_bALMaxPlayers) || (lv_firebatPlayer <= 0))) {
        return true;
    }

    lv_damageAmount = (EventUnitDamageAmount() + EventUnitDamageBehaviorShield());
    lv_damageAmount = (lv_damageAmount * libHFIR_gv_heroFirebatJuggernautPlatingBaseShieldMod);
    libHFIR_gv_heroFirebatJuggernautPlatingCombinedShield[lv_firebatPlayer] += lv_damageAmount;
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHFIR_gt_HeroFirebatJuggernautPlatingDamageTracker_Init () {
    libHFIR_gt_HeroFirebatJuggernautPlatingDamageTracker = TriggerCreate("libHFIR_gt_HeroFirebatJuggernautPlatingDamageTracker_Func");
    TriggerEnable(libHFIR_gt_HeroFirebatJuggernautPlatingDamageTracker, false);
    TriggerAddDamageEvent(libHFIR_gt_HeroFirebatJuggernautPlatingDamageTracker, null, "HeroFirebat", c_unitDamageTypeAbility, c_unitDamageEither, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Firebat - Juggernaut Plating - Apply Shield
//--------------------------------------------------------------------------------------------------
bool libHFIR_gt_HeroFirebatJuggernautPlatingApplyShield_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_firebatUnit;
    int lv_firebatPlayer;
    fixed lv_shieldAmount;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_firebatUnit = EventUnit();
    lv_firebatPlayer = UnitGetOwner(lv_firebatUnit);
    lv_shieldAmount = libHFIR_gv_heroFirebatJuggernautPlatingCombinedShield[lv_firebatPlayer];

    // Conditions
    if (testConds) {
        if (!((lv_shieldAmount > 0.0))) {
            return false;
        }
    }

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

    CatalogFieldValueSetFixed(c_gameCatalogBehavior, "FirebatJuggernautPlatingShieldBehavior", "DamageResponse.ModifyLimit", lv_firebatPlayer, lv_shieldAmount);
    UnitCreateEffectUnit(lv_firebatUnit, "FirebatJuggernautPlatingShieldApplyBehavior", lv_firebatUnit);
    libHFIR_gv_heroFirebatJuggernautPlatingCombinedShield[lv_firebatPlayer] = 0.0;
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHFIR_gt_HeroFirebatJuggernautPlatingApplyShield_Init () {
    libHFIR_gt_HeroFirebatJuggernautPlatingApplyShield = TriggerCreate("libHFIR_gt_HeroFirebatJuggernautPlatingApplyShield_Func");
    TriggerEnable(libHFIR_gt_HeroFirebatJuggernautPlatingApplyShield, false);
    TriggerAddEventUnitBehaviorChange(libHFIR_gt_HeroFirebatJuggernautPlatingApplyShield, null, "FirebatJuggernautPlatingSpellShield", c_unitBehaviorChangeDeactivate);
}

void libHFIR_InitTriggers () {
    libHFIR_gt_HeroFirebatBunkerDropFortifiedBunkerOilSpillCast_Init();
    libHFIR_gt_HeroFirebatBunkerDropFlamethrowerReveal_Init();
    libHFIR_gt_HeroFirebatBunkerDropTurretUnitSelect_Init();
    libHFIR_gt_HeroFirebatBunkerDropEnterTurnAIOn_Init();
    libHFIR_gt_HeroFirebatBunkerDropTurretUnitDeselect_Init();
    libHFIR_gt_HeroFirebatBunkerDropOverlayOn_Init();
    libHFIR_gt_HeroFirebatBunkerDropOverlayOff_Init();
    libHFIR_gt_HeroFirebatBunkerDropOverlayFlamethrowerFXStart_Init();
    libHFIR_gt_HeroFirebatBunkerDropOverlayFlamethrowerFXEnd_Init();
    libHFIR_gt_HeroFirebatJuggernautPlatingDamageTracker_Init();
    libHFIR_gt_HeroFirebatJuggernautPlatingApplyShield_Init();
}

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

void libHFIR_InitLib () {
    if (libHFIR_InitLib_completed) {
        return;
    }

    libHFIR_InitLib_completed = true;

    libHFIR_InitLibraries();
    libHFIR_InitVariables();
    libHFIR_InitTriggers();
}