PTR build 2.57.1.98674_ptr. Go to the live site.

mods/heromods/thefirelords.stormmod/base.stormdata/libhmaj.galaxy

libhmaj.galaxy
include "TriggerLibs/NativeLib"
include "TriggerLibs/HeroesLib"
include "TriggerLibs/GameLib"
include "TriggerLibs/UILib"
include "TriggerLibs/GameDataHelperLib"

include "LibHMaj_h"

//--------------------------------------------------------------------------------------------------
// Library: Ragnaros
//--------------------------------------------------------------------------------------------------
// External Library Initialization
void libHMaj_InitLibraries () {
    libNtve_InitVariables();
    libCore_InitVariables();
    libGame_InitVariables();
    libUIUI_InitVariables();
    libGDHL_InitVariables();
}

// Variable Initialization
bool libHMaj_InitVariables_completed = false;

void libHMaj_InitVariables () {
    if (libHMaj_InitVariables_completed) {
        return;
    }

    libHMaj_InitVariables_completed = true;

    libHMaj_gv_ragnarosSpawned2 = 110.0;
    libHMaj_gv_hero_Ragnaros_BlastWave_TemperedFlameMod_C = 1.0;
}

// Functions
void libHMaj_gf_HeroRagnarosIncrementHeroCountFunction () {
    // Automatic Variable Declarations
    // Implementation
    libHMaj_gv_heroRagnarosTriggerRegistrationVariable += 1;
    if ((libHMaj_gv_heroRagnarosTriggerRegistrationVariable == 1)) {
        TriggerEnable(libHMaj_gt_HeroRagnarosMoltenCore, true);
        TriggerEnable(libHMaj_gt_HeroRagnarosMoltenCoreEnd, true);
        TriggerEnable(libHMaj_gt_HeroRagnarosLavaWavePointTarget, true);
        TriggerEnable(libHMaj_gt_HeroRagnarosEmpowerSulfurasCauterizeWounds, true);
        TriggerEnable(libHMaj_gt_HeroRagnarosMoltenCoreUpdateDurationBar, true);
        TriggerEnable(libHMaj_gt_HeroRagnarosMoltenCoreCreateMarkers, true);
        TriggerEnable(libHMaj_gt_HeroRagnarosMoltenCoreDestroyMarkers, true);
        TriggerEnable(libHMaj_gt_HeroRagnarosMoltenCoreAbathurCloneSetCooldown, true);
        TriggerEnable(libHMaj_gt_HeroRagnarosSubmergeFullscreenOverlayOn, true);
        TriggerEnable(libHMaj_gt_HeroRagnarosSubmergeFullscreenOverlayOff, true);
        TriggerEnable(libHMaj_gt_HeroRagnarosMoltenCoreFullscreenOverlayOn, true);
        TriggerEnable(libHMaj_gt_HeroRagnarosMoltenCoreFullscreenOverlayOff, true);
        TriggerEnable(libHMaj_gt_HeroRagnarosBigRagHealthGlobeRedirect, true);
        TriggerEnable(libHMaj_gt_HeroRagnarosGainsHeroic, true);
        TriggerEnable(libHMaj_gt_HeroRagnarosEmpowerSulfurasResilientFlame, true);
        TriggerEnable(libHMaj_gt_HeroRagnarosMoltenCoreHeroicModeCDReduction, true);
        libGDHL_gv_ragnarosExists = true;
    }

}

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

    if ((libHMaj_gv_heroRagnarosTriggerRegistrationVariable == 0)) {
        TriggerEnable(libHMaj_gt_HeroRagnarosMoltenCore, false);
        TriggerEnable(libHMaj_gt_HeroRagnarosMoltenCoreEnd, false);
        TriggerEnable(libHMaj_gt_HeroRagnarosLavaWavePointTarget, false);
        TriggerEnable(libHMaj_gt_HeroRagnarosEmpowerSulfurasCauterizeWounds, false);
        TriggerEnable(libHMaj_gt_HeroRagnarosMoltenCoreUpdateDurationBar, false);
        TriggerEnable(libHMaj_gt_HeroRagnarosMoltenCoreCreateMarkers, false);
        TriggerEnable(libHMaj_gt_HeroRagnarosMoltenCoreDestroyMarkers, false);
        TriggerEnable(libHMaj_gt_HeroRagnarosMoltenCoreAbathurCloneSetCooldown, false);
        TriggerEnable(libHMaj_gt_HeroRagnarosSubmergeFullscreenOverlayOn, false);
        TriggerEnable(libHMaj_gt_HeroRagnarosSubmergeFullscreenOverlayOff, false);
        TriggerEnable(libHMaj_gt_HeroRagnarosMoltenCoreFullscreenOverlayOn, false);
        TriggerEnable(libHMaj_gt_HeroRagnarosMoltenCoreFullscreenOverlayOff, false);
        TriggerEnable(libHMaj_gt_HeroRagnarosBigRagHealthGlobeRedirect, false);
        TriggerEnable(libHMaj_gt_HeroRagnarosGainsHeroic, false);
        TriggerEnable(libHMaj_gt_HeroRagnarosEmpowerSulfurasResilientFlame, false);
        TriggerEnable(libHMaj_gt_HeroRagnarosMoltenCoreHeroicModeCDReduction, false);
        libGDHL_gv_ragnarosExists = false;
    }

}

trigger auto_libHMaj_gf_HeroRagnarosLavaWaveLaneUnitAI_Trigger = null;
bool auto_libHMaj_gf_HeroRagnarosLavaWaveLaneUnitAI_lp_belongsToOrder;
int auto_libHMaj_gf_HeroRagnarosLavaWaveLaneUnitAI_lp_player;
int auto_libHMaj_gf_HeroRagnarosLavaWaveLaneUnitAI_lp_directionInt;
unit auto_libHMaj_gf_HeroRagnarosLavaWaveLaneUnitAI_lp_laneUnit;
int auto_libHMaj_gf_HeroRagnarosLavaWaveLaneUnitAI_lp_lane;
int auto_libHMaj_gf_HeroRagnarosLavaWaveLaneUnitAI_lp_nextWaypoint;
int auto_libHMaj_gf_HeroRagnarosLavaWaveLaneUnitAI_lp_lastWaypoint;

void libHMaj_gf_HeroRagnarosLavaWaveLaneUnitAI (bool lp_belongsToOrder, int lp_player, int lp_directionInt, unit lp_laneUnit, int lp_lane, int lp_nextWaypoint, int lp_lastWaypoint) {
    auto_libHMaj_gf_HeroRagnarosLavaWaveLaneUnitAI_lp_belongsToOrder = lp_belongsToOrder;
    auto_libHMaj_gf_HeroRagnarosLavaWaveLaneUnitAI_lp_player = lp_player;
    auto_libHMaj_gf_HeroRagnarosLavaWaveLaneUnitAI_lp_directionInt = lp_directionInt;
    auto_libHMaj_gf_HeroRagnarosLavaWaveLaneUnitAI_lp_laneUnit = lp_laneUnit;
    auto_libHMaj_gf_HeroRagnarosLavaWaveLaneUnitAI_lp_lane = lp_lane;
    auto_libHMaj_gf_HeroRagnarosLavaWaveLaneUnitAI_lp_nextWaypoint = lp_nextWaypoint;
    auto_libHMaj_gf_HeroRagnarosLavaWaveLaneUnitAI_lp_lastWaypoint = lp_lastWaypoint;

    if (auto_libHMaj_gf_HeroRagnarosLavaWaveLaneUnitAI_Trigger == null) {
        auto_libHMaj_gf_HeroRagnarosLavaWaveLaneUnitAI_Trigger = TriggerCreate("auto_libHMaj_gf_HeroRagnarosLavaWaveLaneUnitAI_TriggerFunc");
    }

    TriggerExecute(auto_libHMaj_gf_HeroRagnarosLavaWaveLaneUnitAI_Trigger, false, false);
}

bool auto_libHMaj_gf_HeroRagnarosLavaWaveLaneUnitAI_TriggerFunc (bool testConds, bool runActions) {
    bool lp_belongsToOrder = auto_libHMaj_gf_HeroRagnarosLavaWaveLaneUnitAI_lp_belongsToOrder;
    int lp_player = auto_libHMaj_gf_HeroRagnarosLavaWaveLaneUnitAI_lp_player;
    int lp_directionInt = auto_libHMaj_gf_HeroRagnarosLavaWaveLaneUnitAI_lp_directionInt;
    unit lp_laneUnit = auto_libHMaj_gf_HeroRagnarosLavaWaveLaneUnitAI_lp_laneUnit;
    int lp_lane = auto_libHMaj_gf_HeroRagnarosLavaWaveLaneUnitAI_lp_lane;
    int lp_nextWaypoint = auto_libHMaj_gf_HeroRagnarosLavaWaveLaneUnitAI_lp_nextWaypoint;
    int lp_lastWaypoint = auto_libHMaj_gf_HeroRagnarosLavaWaveLaneUnitAI_lp_lastWaypoint;

    // Variable Declarations
    int lv_myLavaWaveIndex;
    int lv_waypoint;
    int lv_waypointIndex;
    bool lv_atMaximumConcurrentActiveLavaWaveMinimapPaths;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_waypoint = lp_nextWaypoint;
    lv_waypointIndex = 1;

    // Implementation
    lv_myLavaWaveIndex = libHMaj_gv_lavaWaveCurrentIndex[lp_player];
    libHMaj_gv_lavaWaveCurrentIndex[lp_player] = (1 - libHMaj_gv_lavaWaveCurrentIndex[lp_player]);
    UnitIssueOrder(lp_laneUnit, OrderTargetingPoint(AbilityCommand("move", 0), libGame_gv_laneData[lp_lane].lv_waypoints[lv_waypoint]), c_orderQueueReplace);
    if ((libHMaj_gv_lavaWaveMiniMapPathId[lp_player][0] != 0)) {
        if ((libHMaj_gv_lavaWaveMiniMapPathId[lp_player][1] != 0)) {
            lv_atMaximumConcurrentActiveLavaWaveMinimapPaths = true;
        }
        else {
            lv_myLavaWaveIndex = 1;
            libHMaj_gv_lavaWaveCurrentIndex[lp_player] = (1 - libHMaj_gv_lavaWaveCurrentIndex[lp_player]);
        }
    }
    else {
        lv_myLavaWaveIndex = 0;
        libHMaj_gv_lavaWaveCurrentIndex[lp_player] = (1 - libHMaj_gv_lavaWaveCurrentIndex[lp_player]);
    }
    if ((lv_atMaximumConcurrentActiveLavaWaveMinimapPaths != true)) {
        libHMaj_gf_HeroRagnarosLavaWaveMinimapPathSetup(lp_belongsToOrder, lp_laneUnit, lp_lane, lv_waypoint, lp_lastWaypoint, lp_directionInt, lp_player, lv_myLavaWaveIndex);
    }

    while ((UnitIsAlive(lp_laneUnit) == true)) {
        if ((UnitHasBehavior2(lp_laneUnit, "HallOfStormsKnockbackDebuff") == true)) {
            UnitKill(lp_laneUnit);
            if ((lv_atMaximumConcurrentActiveLavaWaveMinimapPaths != true)) {
                libHMaj_gf_HeroRagnarosLavaWaveMinimapPathCleanup(lp_player, lv_myLavaWaveIndex);
            }

        }

        if ((DistanceBetweenPoints(UnitGetPosition(lp_laneUnit), libGame_gv_laneData[lp_lane].lv_waypoints[lv_waypoint]) < 2.0)) {
            if ((DistanceBetweenPoints(UnitGetPosition(lp_laneUnit), libGame_gv_laneData[lp_lane].lv_waypoints[lp_lastWaypoint]) < 2.0)) {
                UnitKill(lp_laneUnit);
                if ((lv_atMaximumConcurrentActiveLavaWaveMinimapPaths != true)) {
                    libHMaj_gf_HeroRagnarosLavaWaveMinimapPathCleanup(lp_player, lv_myLavaWaveIndex);
                }

            }
            else {
                lv_waypoint = (lv_waypoint + lp_directionInt);
                UnitIssueOrder(lp_laneUnit, OrderTargetingPoint(AbilityCommand("move", 0), libGame_gv_laneData[lp_lane].lv_waypoints[lv_waypoint]), c_orderQueueReplace);
                if ((lv_atMaximumConcurrentActiveLavaWaveMinimapPaths != true)) {
                    PathSetWayPointIndexStart(libHMaj_gv_lavaWaveMiniMapPathId[lp_player][lv_myLavaWaveIndex], lv_waypointIndex);
                }

                lv_waypointIndex = (lv_waypointIndex+1);
            }
        }

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

void libHMaj_gf_HeroRagnarosLavaWaveMinimapPathSetup (bool lp_belongsToOrder, unit lp_lavaWaveUnit, int lp_currentLane, int lp_startingWaypoint, int lp_endingWaypoint, int lp_waypointDelta, int lp_player, int lp_lavaWaveIndex) {
    // Variable Declarations
    int lv_currentWaypoint;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_currentWaypoint = lp_startingWaypoint;

    // Implementation
    libHMaj_gf_HeroRagnarosLavaWaveMinimapPathCleanup(lp_player, lp_lavaWaveIndex);
    PathCreateForUnit(PlayerGroupAll(), lp_lavaWaveUnit);
    PathSetLineTexture(PathLastCreated(), c_pathLocationMinimap, "Assets\\Textures\\storm_ui_minimap_lavawave_waypointline.dds");
    libHMaj_gv_lavaWaveMiniMapPathId[lp_player][lp_lavaWaveIndex] = PathLastCreated();
    PathSetVisible(libHMaj_gv_lavaWaveMiniMapPathId[lp_player][lp_lavaWaveIndex], c_pathLocationWorld, false);
    while ((lp_endingWaypoint > 0) && (lv_currentWaypoint != lp_endingWaypoint)) {
        lv_currentWaypoint = (lv_currentWaypoint + lp_waypointDelta);
        PathAddWayPoint(libHMaj_gv_lavaWaveMiniMapPathId[lp_player][lp_lavaWaveIndex], libGame_gv_laneData[lp_currentLane].lv_waypoints[lv_currentWaypoint]);
    }
    PathSetDestinationPoint(libHMaj_gv_lavaWaveMiniMapPathId[lp_player][lp_lavaWaveIndex], libGame_gv_laneData[lp_currentLane].lv_waypoints[lv_currentWaypoint]);
    PathSetOwnerPlayerId(libHMaj_gv_lavaWaveMiniMapPathId[lp_player][lp_lavaWaveIndex], lp_player);
}

void libHMaj_gf_HeroRagnarosLavaWaveMinimapPathCleanup (int lp_player, int lp_lavaWaveIndex) {
    // Automatic Variable Declarations
    // Implementation
    if ((libHMaj_gv_lavaWaveMiniMapPathId[lp_player][lp_lavaWaveIndex] != 0)) {
        PathClearWayPoints(libHMaj_gv_lavaWaveMiniMapPathId[lp_player][lp_lavaWaveIndex]);
        PathDestroy(libHMaj_gv_lavaWaveMiniMapPathId[lp_player][lp_lavaWaveIndex]);
        libHMaj_gv_lavaWaveMiniMapPathId[lp_player][lp_lavaWaveIndex] = 0;
    }

}

// Triggers
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Ragnaros - Molten Core - Heroic Mode CD Reduction
//--------------------------------------------------------------------------------------------------
bool libHMaj_gt_HeroRagnarosMoltenCoreHeroicModeCDReduction_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_bigRagUnit;
    int lv_ragnarosPlayer;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_bigRagUnit = EventUnit();
    lv_ragnarosPlayer = UnitGetOwner(lv_bigRagUnit);

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

    if ((UnitTestState(EventUnitTargetUnit(), c_unitStateIsDead) == true) && (PlayerHasTalent(lv_ragnarosPlayer, "RagnarosMoltenCoreHeroicDifficulty") == true)) {
        libHMaj_gv_ragnarosUnit3[UnitGetOwner(EventUnit())] = true;
    }
    else {
        libHMaj_gv_ragnarosUnit3[UnitGetOwner(EventUnit())] = false;
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHMaj_gt_HeroRagnarosMoltenCoreHeroicModeCDReduction_Init () {
    libHMaj_gt_HeroRagnarosMoltenCoreHeroicModeCDReduction = TriggerCreate("libHMaj_gt_HeroRagnarosMoltenCoreHeroicModeCDReduction_Func");
    TriggerEnable(libHMaj_gt_HeroRagnarosMoltenCoreHeroicModeCDReduction, false);
    TriggerAddEventUnitAbility(libHMaj_gt_HeroRagnarosMoltenCoreHeroicModeCDReduction, null, AbilityCommand("RagnarosMoltenCore", 0), c_unitAbilStageComplete, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Ragnaros - Molten Core
//--------------------------------------------------------------------------------------------------
bool libHMaj_gt_HeroRagnarosMoltenCore_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_structureRagnarosUnit;
    int lv_ragnarosPlayer;
    unit lv_regularRagnarosUnit;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_structureRagnarosUnit = EventUnitCreatedUnit();
    lv_ragnarosPlayer = UnitGetOwner(lv_structureRagnarosUnit);
    lv_regularRagnarosUnit = libGame_gv_players[lv_ragnarosPlayer].lv_heroUnit;

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

    libHMaj_gv_ragnarosUnit2[lv_ragnarosPlayer] = EventUnitCreatedUnit();
    UnitSelect(lv_regularRagnarosUnit, lv_ragnarosPlayer, false);
    UnitSelect(lv_structureRagnarosUnit, lv_ragnarosPlayer, true);
    UnitSelect(lv_regularRagnarosUnit, lv_ragnarosPlayer, true);
    libGame_gf_SendEventHeroUnitSwappedForPlayer(lv_regularRagnarosUnit, lv_structureRagnarosUnit, lv_ragnarosPlayer, false);
    libGame_gv_players[lv_ragnarosPlayer].lv_cameraPlayerUnitGroupToFocusOn = libNtve_gf_ConvertUnitToUnitGroup(lv_structureRagnarosUnit);
    libGame_gv_players[lv_ragnarosPlayer].lv_activeVehicle = libHMaj_gv_ragnarosUnit2[lv_ragnarosPlayer];
    libGame_gf_CameraUpdateCameraForPlayer(lv_ragnarosPlayer);
    libUIUI_gf_UIHeroConsoleSetUpForPlayer(lv_structureRagnarosUnit, lv_ragnarosPlayer);
    libUIUI_gf_HeroConsoleUnitStatusBarsSetUnitForBars(lv_structureRagnarosUnit, lv_ragnarosPlayer);
    if ((libGame_gf_TeamNumberOfPlayer(lv_ragnarosPlayer) == 1)) {
        UnitSetFacing(lv_structureRagnarosUnit, 300.0, 0.0);
    }
    else {
        UnitSetFacing(lv_structureRagnarosUnit, 250.0, 0.0);
    }
    AIRemovePlayerUnit(lv_regularRagnarosUnit);
    AIAddPlayerUnit(lv_structureRagnarosUnit);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHMaj_gt_HeroRagnarosMoltenCore_Init () {
    libHMaj_gt_HeroRagnarosMoltenCore = TriggerCreate("libHMaj_gt_HeroRagnarosMoltenCore_Func");
    TriggerEnable(libHMaj_gt_HeroRagnarosMoltenCore, false);
    TriggerAddEventUnitCreated(libHMaj_gt_HeroRagnarosMoltenCore, null, "RagnarosMoltenCore", null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Ragnaros - Molten Core End
//--------------------------------------------------------------------------------------------------
bool libHMaj_gt_HeroRagnarosMoltenCoreEnd_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_regularRagnarosUnit;
    int lv_ragnarosPlayer;
    unit lv_structureRagnarosUnit;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_regularRagnarosUnit = EventUnit();
    lv_ragnarosPlayer = UnitGetOwner(lv_regularRagnarosUnit);
    lv_structureRagnarosUnit = libHMaj_gv_ragnarosUnit2[lv_ragnarosPlayer];

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

    libHMaj_gv_ragnarosUnit2[lv_ragnarosPlayer] = null;
    UnitSelect(lv_regularRagnarosUnit, lv_ragnarosPlayer, true);
    if ((libHMaj_gv_ragnarosUnit3[lv_ragnarosPlayer] == false)) {
        UnitModifyCooldown(lv_regularRagnarosUnit, "Abil/RagnarosMoltenCore", CatalogFieldValueGetAsInt(c_gameCatalogAbil, "RagnarosMoltenCore", "Cost.Cooldown.TimeUse", lv_ragnarosPlayer), c_cooldownOperationSet);
    }
    else {
        UnitModifyCooldown(lv_regularRagnarosUnit, "Abil/RagnarosMoltenCore", (CatalogFieldValueGetAsInt(c_gameCatalogAbil, "RagnarosMoltenCore", "Cost.Cooldown.TimeUse", c_playerAny) - libHMaj_gv_ragnarosSpawned2), c_cooldownOperationSet);
    }
    libGame_gv_players[lv_ragnarosPlayer].lv_cameraPlayerUnitGroupToFocusOn = libNtve_gf_ConvertUnitToUnitGroup(lv_regularRagnarosUnit);
    libGame_gv_players[lv_ragnarosPlayer].lv_activeVehicle = null;
    libGame_gf_SendEventHeroUnitSwappedForPlayer(lv_structureRagnarosUnit, lv_regularRagnarosUnit, lv_ragnarosPlayer, false);
    libGame_gf_CameraUpdateCameraForPlayer(lv_ragnarosPlayer);
    libGame_gf_CameraPanCameraForPlayerAndUpdateMapBoundsIfNecessary(lv_ragnarosPlayer, UnitGetPosition(lv_regularRagnarosUnit), 0.0, -1, 0.0, false);
    libUIUI_gf_UIHeroConsoleSetUpForPlayer(lv_regularRagnarosUnit, lv_ragnarosPlayer);
    libUIUI_gf_HeroConsoleUnitStatusBarsSetUnitForBars(lv_regularRagnarosUnit, lv_ragnarosPlayer);
    AIAddPlayerUnit(lv_regularRagnarosUnit);
    AIRemovePlayerUnit(lv_structureRagnarosUnit);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHMaj_gt_HeroRagnarosMoltenCoreEnd_Init () {
    libHMaj_gt_HeroRagnarosMoltenCoreEnd = TriggerCreate("libHMaj_gt_HeroRagnarosMoltenCoreEnd_Func");
    TriggerEnable(libHMaj_gt_HeroRagnarosMoltenCoreEnd, false);
    TriggerAddEventUnitBehaviorChange(libHMaj_gt_HeroRagnarosMoltenCoreEnd, null, "RagnarosMoltenCoreCasterStasis", c_unitBehaviorChangeDestroy);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Ragnaros - Molten Core -- Update Duration Bar
//--------------------------------------------------------------------------------------------------
bool libHMaj_gt_HeroRagnarosMoltenCoreUpdateDurationBar_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_bigRagnarosUnit;
    int lv_ragnarosPlayer;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_bigRagnarosUnit = EventUnit();
    lv_ragnarosPlayer = UnitGetOwner(lv_bigRagnarosUnit);

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

    UnitBehaviorSetDuration(lv_bigRagnarosUnit, "RagnarosMoltenCoreDuration", ((UnitGetPropertyFixed(EventUnit(), c_unitPropLifeMax, c_unitPropCurrent) / AbsF(UnitGetPropertyFixed(EventUnit(), c_unitPropLifeRegen, c_unitPropCurrent)))));
    while ((UnitIsAlive(lv_bigRagnarosUnit) == true)) {
        UnitBehaviorSetDurationRemaining(lv_bigRagnarosUnit, "RagnarosMoltenCoreDuration", ((UnitGetPropertyFixed(EventUnit(), c_unitPropLifeMax, c_unitPropCurrent) / AbsF(UnitGetPropertyFixed(EventUnit(), c_unitPropLifeRegen, c_unitPropCurrent))) * (UnitGetPropertyFixed(lv_bigRagnarosUnit, c_unitPropLifePercent, c_unitPropCurrent) / 100)));
        Wait(0.0625, c_timeGame);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHMaj_gt_HeroRagnarosMoltenCoreUpdateDurationBar_Init () {
    libHMaj_gt_HeroRagnarosMoltenCoreUpdateDurationBar = TriggerCreate("libHMaj_gt_HeroRagnarosMoltenCoreUpdateDurationBar_Func");
    TriggerEnable(libHMaj_gt_HeroRagnarosMoltenCoreUpdateDurationBar, false);
    TriggerAddEventUnitBehaviorChange(libHMaj_gt_HeroRagnarosMoltenCoreUpdateDurationBar, null, "RagnarosMoltenCoreDuration", c_unitBehaviorChangeCreate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Ragnaros - Molten Core - Create Markers
//--------------------------------------------------------------------------------------------------
bool libHMaj_gt_HeroRagnarosMoltenCoreCreateMarkers_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_ragnarosPlayer;
    unit lv_ragnarosUnit;
    int lv_itUnit;
    unit lv_townHall;

    // Automatic Variable Declarations
    int auto1C6FAD2A_ae;
    const int auto1C6FAD2A_ai = 1;

    // Variable Initialization
    lv_ragnarosPlayer = EventPlayer();
    lv_ragnarosUnit = libGame_gv_players[lv_ragnarosPlayer].lv_heroUnit;

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

    auto1C6FAD2A_ae = libGame_gv_townTownCount;
    lv_itUnit = 1;
    for ( ; ( (auto1C6FAD2A_ai >= 0 && lv_itUnit <= auto1C6FAD2A_ae) || (auto1C6FAD2A_ai < 0 && lv_itUnit >= auto1C6FAD2A_ae) ) ; lv_itUnit += auto1C6FAD2A_ai ) {
        if ((libGame_gv_townTownData[lv_itUnit].lv_townHallIndex != -1)) {
            lv_townHall = libGame_gv_townTownData[lv_itUnit].lv_structureUnits[libGame_gv_townTownData[lv_itUnit].lv_townHallIndex];
            if (((UnitFilterMatch(lv_townHall, lv_ragnarosPlayer, UnitFilter(0, 0, (1 << c_targetFilterPlayer) | (1 << c_targetFilterNeutral) | (1 << c_targetFilterEnemy) | (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)))) == true) || (UnitFilterMatch(lv_townHall, lv_ragnarosPlayer, UnitFilter(0, (1 << (c_targetFilterDead - 32)), (1 << c_targetFilterPlayer) | (1 << c_targetFilterNeutral) | (1 << c_targetFilterMissile), (1 << (c_targetFilterHidden - 32)))) == true))) {
                UnitCreateEffectUnit(lv_ragnarosUnit, "RagnarosMoltenCoreCreateMarkerTriggerEffect", lv_townHall);
            }

        }

    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHMaj_gt_HeroRagnarosMoltenCoreCreateMarkers_Init () {
    libHMaj_gt_HeroRagnarosMoltenCoreCreateMarkers = TriggerCreate("libHMaj_gt_HeroRagnarosMoltenCoreCreateMarkers_Func");
    TriggerEnable(libHMaj_gt_HeroRagnarosMoltenCoreCreateMarkers, false);
    TriggerAddEventTargetModeUpdate(libHMaj_gt_HeroRagnarosMoltenCoreCreateMarkers, c_playerAny, AbilityCommand("RagnarosMoltenCore", 0), c_targetModeStateOn);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Ragnaros - Molten Core - Destroy Markers
//--------------------------------------------------------------------------------------------------
bool libHMaj_gt_HeroRagnarosMoltenCoreDestroyMarkers_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_ragnarosPlayer;
    unit lv_ragnarosUnit;
    int lv_itUnit;
    unit lv_townHall;

    // Automatic Variable Declarations
    int autoDC7D0AD8_ae;
    const int autoDC7D0AD8_ai = 1;

    // Variable Initialization
    lv_ragnarosPlayer = EventPlayer();
    lv_ragnarosUnit = libGame_gv_players[lv_ragnarosPlayer].lv_heroUnit;

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

    autoDC7D0AD8_ae = libGame_gv_townTownCount;
    lv_itUnit = 1;
    for ( ; ( (autoDC7D0AD8_ai >= 0 && lv_itUnit <= autoDC7D0AD8_ae) || (autoDC7D0AD8_ai < 0 && lv_itUnit >= autoDC7D0AD8_ae) ) ; lv_itUnit += autoDC7D0AD8_ai ) {
        if ((libGame_gv_townTownData[lv_itUnit].lv_townHallIndex != -1)) {
            lv_townHall = libGame_gv_townTownData[lv_itUnit].lv_structureUnits[libGame_gv_townTownData[lv_itUnit].lv_townHallIndex];
            if (((UnitFilterMatch(lv_townHall, lv_ragnarosPlayer, UnitFilter(0, 0, (1 << c_targetFilterPlayer) | (1 << c_targetFilterNeutral) | (1 << c_targetFilterEnemy) | (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)))) == true) || (UnitFilterMatch(lv_townHall, lv_ragnarosPlayer, UnitFilter(0, (1 << (c_targetFilterDead - 32)), (1 << c_targetFilterPlayer) | (1 << c_targetFilterNeutral) | (1 << c_targetFilterMissile), (1 << (c_targetFilterHidden - 32)))) == true))) {
                UnitCreateEffectUnit(lv_ragnarosUnit, "RagnarosMoltenCoreDestroyMarkerTriggerEffect", lv_townHall);
            }

        }

    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHMaj_gt_HeroRagnarosMoltenCoreDestroyMarkers_Init () {
    libHMaj_gt_HeroRagnarosMoltenCoreDestroyMarkers = TriggerCreate("libHMaj_gt_HeroRagnarosMoltenCoreDestroyMarkers_Func");
    TriggerEnable(libHMaj_gt_HeroRagnarosMoltenCoreDestroyMarkers, false);
    TriggerAddEventTargetModeUpdate(libHMaj_gt_HeroRagnarosMoltenCoreDestroyMarkers, c_playerAny, AbilityCommand("RagnarosMoltenCore", 0), c_targetModeStateOff);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Ragnaros - Molten Core Fullscreen Overlay On
//--------------------------------------------------------------------------------------------------
bool libHMaj_gt_HeroRagnarosMoltenCoreFullscreenOverlayOn_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    if ((UnitHasBehavior2(EventUnit(), "HeroGenericIgnoreFullscreenOverlay") == false)) {
        libUIUI_gf_FullscreenOverlayStopandClearCutsceneQueueForPlayer(EventPlayer());
        libUIUI_gf_FullscreenOverlayAddItemForPlayer(EventPlayer(), libUIUI_ge_FullscreenOverlayPriorities_Stasis, "Cutscenes\\GameUI_RagnarosSummonOverlay.StormCutscene", EventUnitBehavior());
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libHMaj_gt_HeroRagnarosMoltenCoreFullscreenOverlayOn_Init () {
    libHMaj_gt_HeroRagnarosMoltenCoreFullscreenOverlayOn = TriggerCreate("libHMaj_gt_HeroRagnarosMoltenCoreFullscreenOverlayOn_Func");
    TriggerEnable(libHMaj_gt_HeroRagnarosMoltenCoreFullscreenOverlayOn, false);
    TriggerAddEventUnitBehaviorChange(libHMaj_gt_HeroRagnarosMoltenCoreFullscreenOverlayOn, null, "RagnarosMoltenCoreCasterStasis", c_unitBehaviorChangeActivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Ragnaros - Molten Core Fullscreen Overlay Off
//--------------------------------------------------------------------------------------------------
bool libHMaj_gt_HeroRagnarosMoltenCoreFullscreenOverlayOff_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    if ((UnitHasBehavior2(EventUnit(), "HeroGenericIgnoreFullscreenOverlay") == false)) {
        libUIUI_gf_FullscreenOverlayRemoveItemFromQueueForPlayer(EventPlayer(), "Cutscenes\\GameUI_RagnarosSummonOverlay.StormCutscene", EventUnitBehavior());
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libHMaj_gt_HeroRagnarosMoltenCoreFullscreenOverlayOff_Init () {
    libHMaj_gt_HeroRagnarosMoltenCoreFullscreenOverlayOff = TriggerCreate("libHMaj_gt_HeroRagnarosMoltenCoreFullscreenOverlayOff_Func");
    TriggerEnable(libHMaj_gt_HeroRagnarosMoltenCoreFullscreenOverlayOff, false);
    TriggerAddEventUnitBehaviorChange(libHMaj_gt_HeroRagnarosMoltenCoreFullscreenOverlayOff, null, "RagnarosMoltenCoreCasterStasis", c_unitBehaviorChangeDestroy);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Ragnaros - Molten Core - Abathur Clone Set Cooldown
//--------------------------------------------------------------------------------------------------
bool libHMaj_gt_HeroRagnarosMoltenCoreAbathurCloneSetCooldown_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((UnitHasBehavior2(EventUnitCreatedUnit(), "UltimateEvolutionBuff") == true))) {
            return false;
        }

        if (!((UnitGetType(EventUnitCreatedUnit()) == "HeroRagnaros"))) {
            return false;
        }
    }

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

    UnitAbilityReset(EventUnitCreatedUnit(), AbilityCommand("RagnarosMoltenCore", 0), c_spendLocationUnit);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHMaj_gt_HeroRagnarosMoltenCoreAbathurCloneSetCooldown_Init () {
    libHMaj_gt_HeroRagnarosMoltenCoreAbathurCloneSetCooldown = TriggerCreate("libHMaj_gt_HeroRagnarosMoltenCoreAbathurCloneSetCooldown_Func");
    TriggerEnable(libHMaj_gt_HeroRagnarosMoltenCoreAbathurCloneSetCooldown, false);
    TriggerAddEventUnitCreated(libHMaj_gt_HeroRagnarosMoltenCoreAbathurCloneSetCooldown, null, null, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Ragnaros - Big Rag - Health Globe Redirect
//--------------------------------------------------------------------------------------------------
bool libHMaj_gt_HeroRagnarosBigRagHealthGlobeRedirect_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_bigRagUnit;
    int lv_ragnarosPlayer;
    unit lv_ragnarosUnit;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_bigRagUnit = EventUnit();
    lv_ragnarosPlayer = UnitGetOwner(lv_bigRagUnit);
    lv_ragnarosUnit = libGame_gv_players[lv_ragnarosPlayer].lv_heroUnit;

    // Conditions
    if (testConds) {
        if (!((UnitGetType(lv_bigRagUnit) == "RagnarosBigRag"))) {
            return false;
        }
    }

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

    if ((PlayerHasTalent(lv_ragnarosPlayer, "RagnarosCatchingFire") == true)) {
        UnitCreateEffectUnit(lv_ragnarosUnit, "RagnarosCatchingFireAddToken", lv_ragnarosUnit);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libHMaj_gt_HeroRagnarosBigRagHealthGlobeRedirect_Init () {
    libHMaj_gt_HeroRagnarosBigRagHealthGlobeRedirect = TriggerCreate("libHMaj_gt_HeroRagnarosBigRagHealthGlobeRedirect_Func");
    TriggerEnable(libHMaj_gt_HeroRagnarosBigRagHealthGlobeRedirect, false);
    TriggerAddEventUnitBehaviorChange(libHMaj_gt_HeroRagnarosBigRagHealthGlobeRedirect, null, "RegenGlobePercentBuff", c_unitBehaviorChangeCreate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Ragnaros - Lava Wave Point Target
//--------------------------------------------------------------------------------------------------
bool libHMaj_gt_HeroRagnarosLavaWavePointTarget_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_castingUnit;
    int lv_targetLane;
    point lv_targetPoint;
    int lv_unitCounter;
    const int lv_c_NumUnitsPerLane = 1;
    int lv_ragnarosPlayer;
    unit lv_itUnit;
    unit lv_ragnarosUnit;
    int lv_itPoint;
    int lv_firstWaypoint_Order;
    int lv_firstWaypoint_Chaos;
    int lv_lastWaypoint_Order;
    int lv_lastWaypoint_Chaos;

    // Automatic Variable Declarations
    const int autoEA04AE5C_ae = lv_c_NumUnitsPerLane;
    const int autoEA04AE5C_ai = 1;
    int autoAFD6490F_val;

    // Variable Initialization
    lv_castingUnit = EventPlayerEffectUsedUnit(c_effectUnitCaster);
    lv_targetPoint = EventPlayerEffectUsedPoint(c_effectLocationTargetPoint);
    lv_ragnarosPlayer = UnitGetOwner(lv_castingUnit);
    lv_firstWaypoint_Order = 2;
    lv_lastWaypoint_Chaos = 2;

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

    lv_targetLane = AILaneWaypointGetClosestLane(lv_targetPoint);
    lv_unitCounter = 1;
    for ( ; ( (autoEA04AE5C_ai >= 0 && lv_unitCounter <= autoEA04AE5C_ae) || (autoEA04AE5C_ai < 0 && lv_unitCounter >= autoEA04AE5C_ae) ) ; lv_unitCounter += autoEA04AE5C_ai ) {
        autoAFD6490F_val = libGame_gf_TeamNumberOfPlayer(lv_ragnarosPlayer);
        if (autoAFD6490F_val == libGame_gf_TeamNumberOfPlayer(libCore_gv_cOMPUTER_TeamOrder)) {
            lv_lastWaypoint_Order = (libGame_gv_laneData[lv_targetLane].lv_waypointCount - 1);
            libNtve_gf_CreateUnitsWithDefaultFacing(1, "RagnarosLavaWaveLaneUnit", 0, lv_ragnarosPlayer, libGame_gv_laneData[lv_targetLane].lv_waypoints[lv_firstWaypoint_Order], lv_castingUnit);
            lv_itUnit = UnitLastCreated();
            UnitCreateEffectUnit(lv_castingUnit, "RagnarosLavaWaveTrail", lv_itUnit);
            lv_lastWaypoint_Order = (libGame_gv_laneData[lv_targetLane].lv_waypointCount - 1);
            libHMaj_gf_HeroRagnarosLavaWaveLaneUnitAI(true, lv_ragnarosPlayer, 1, lv_itUnit, lv_targetLane, lv_firstWaypoint_Order, lv_lastWaypoint_Order);
        }
        else if (autoAFD6490F_val == libGame_gf_TeamNumberOfPlayer(libCore_gv_cOMPUTER_TeamChaos)) {
            lv_firstWaypoint_Chaos = (libGame_gv_laneData[lv_targetLane].lv_waypointCount - 1);
            libNtve_gf_CreateUnitsWithDefaultFacing(1, "RagnarosLavaWaveLaneUnit", 0, lv_ragnarosPlayer, libGame_gv_laneData[lv_targetLane].lv_waypoints[lv_firstWaypoint_Chaos], lv_castingUnit);
            lv_itUnit = UnitLastCreated();
            UnitCreateEffectUnit(lv_castingUnit, "RagnarosLavaWaveTrail", lv_itUnit);
            lv_firstWaypoint_Chaos = (libGame_gv_laneData[lv_targetLane].lv_waypointCount - 1);
            libHMaj_gf_HeroRagnarosLavaWaveLaneUnitAI(false, lv_ragnarosPlayer, -1, lv_itUnit, lv_targetLane, lv_firstWaypoint_Chaos, lv_lastWaypoint_Chaos);
        }
        else {
        }
        Wait(0.5, c_timeGame);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHMaj_gt_HeroRagnarosLavaWavePointTarget_Init () {
    libHMaj_gt_HeroRagnarosLavaWavePointTarget = TriggerCreate("libHMaj_gt_HeroRagnarosLavaWavePointTarget_Func");
    TriggerEnable(libHMaj_gt_HeroRagnarosLavaWavePointTarget, false);
    TriggerAddEventPlayerEffectUsed(libHMaj_gt_HeroRagnarosLavaWavePointTarget, c_playerAny, "RagnarosLavaWaveTargetPoint");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Ragnaros - Submerge Fullscreen Overlay On
//--------------------------------------------------------------------------------------------------
bool libHMaj_gt_HeroRagnarosSubmergeFullscreenOverlayOn_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    if ((UnitHasBehavior2(EventUnit(), "HeroGenericIgnoreFullscreenOverlay") == false)) {
        libUIUI_gf_FullscreenOverlayAddItemForPlayer(EventPlayer(), libUIUI_ge_FullscreenOverlayPriorities_Stasis, "Cutscenes\\GameUI_RagnarosSubmergeOverlay.StormCutscene", EventUnitBehavior());
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libHMaj_gt_HeroRagnarosSubmergeFullscreenOverlayOn_Init () {
    libHMaj_gt_HeroRagnarosSubmergeFullscreenOverlayOn = TriggerCreate("libHMaj_gt_HeroRagnarosSubmergeFullscreenOverlayOn_Func");
    TriggerEnable(libHMaj_gt_HeroRagnarosSubmergeFullscreenOverlayOn, false);
    TriggerAddEventUnitBehaviorChange(libHMaj_gt_HeroRagnarosSubmergeFullscreenOverlayOn, null, "RagnarosSubmerge", c_unitBehaviorChangeActivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Ragnaros - Submerge Fullscreen Overlay Off
//--------------------------------------------------------------------------------------------------
bool libHMaj_gt_HeroRagnarosSubmergeFullscreenOverlayOff_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    if ((UnitHasBehavior2(EventUnit(), "HeroGenericIgnoreFullscreenOverlay") == false)) {
        libUIUI_gf_FullscreenOverlayRemoveItemFromQueueForPlayer(EventPlayer(), "Cutscenes\\GameUI_RagnarosSubmergeOverlay.StormCutscene", EventUnitBehavior());
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libHMaj_gt_HeroRagnarosSubmergeFullscreenOverlayOff_Init () {
    libHMaj_gt_HeroRagnarosSubmergeFullscreenOverlayOff = TriggerCreate("libHMaj_gt_HeroRagnarosSubmergeFullscreenOverlayOff_Func");
    TriggerEnable(libHMaj_gt_HeroRagnarosSubmergeFullscreenOverlayOff, false);
    TriggerAddEventUnitBehaviorChange(libHMaj_gt_HeroRagnarosSubmergeFullscreenOverlayOff, null, "RagnarosSubmerge", c_unitBehaviorChangeDestroy);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Ragnaros - Gains Heroic
//--------------------------------------------------------------------------------------------------
bool libHMaj_gt_HeroRagnarosGainsHeroic_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_ragnarosPlayer;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_ragnarosPlayer = libGame_gf_HeroGainTalentPlayer();

    // Conditions
    if (testConds) {
        if (!((libHMaj_gv_ragnarosUnit2[lv_ragnarosPlayer] != null))) {
            return false;
        }

        if (!(((libGame_gf_HeroGainTalentGainedTalent() == "RagnarosLavaWave") || (libGame_gf_HeroGainTalentGainedTalent() == "RagnarosSulfurasSmash")))) {
            return false;
        }
    }

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

    if ((libGame_gf_HeroGainTalentGainedTalent() == "RagnarosSulfurasSmash")) {
        UnitBehaviorAdd(libHMaj_gv_ragnarosUnit2[lv_ragnarosPlayer], "Ultimate1Unlocked", libHMaj_gv_ragnarosUnit2[lv_ragnarosPlayer], 1);
    }
    else {
        UnitBehaviorAdd(libHMaj_gv_ragnarosUnit2[lv_ragnarosPlayer], "Ultimate2Unlocked", libHMaj_gv_ragnarosUnit2[lv_ragnarosPlayer], 1);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHMaj_gt_HeroRagnarosGainsHeroic_Init () {
    libHMaj_gt_HeroRagnarosGainsHeroic = TriggerCreate("libHMaj_gt_HeroRagnarosGainsHeroic_Func");
    TriggerEnable(libHMaj_gt_HeroRagnarosGainsHeroic, false);
    libGame_gf_HeroGainTalent(libHMaj_gt_HeroRagnarosGainsHeroic);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Ragnaros - Empower Sulfuras - Cauterize Wounds
//--------------------------------------------------------------------------------------------------
bool libHMaj_gt_HeroRagnarosEmpowerSulfurasCauterizeWounds_Func (bool testConds, bool runActions) {
    // Variable Declarations
    string lv_effect;
    unit lv_damagedUnit;
    unit lv_ragnarosUnit;
    int lv_owner;
    fixed lv_damageAmount;
    fixed lv_periodCount;
    fixed lv_tokenValue;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_effect = EventUnitDamageEffect();
    lv_damagedUnit = EventUnit();
    lv_ragnarosUnit = EventUnitDamageSourceUnit();
    lv_owner = UnitGetOwner(lv_ragnarosUnit);

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

        if (!((UnitIsAlive(lv_ragnarosUnit) == true))) {
            return false;
        }
    }

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

    lv_damageAmount = (EventUnitDamageAmount() + EventUnitDamageBehaviorShield());
    lv_periodCount = (CatalogFieldValueGetAsFixed(c_gameCatalogBehavior, "RagnarosEmpowerSulfurasCauterizeWoundsHeal", "Duration", c_playerAny) / CatalogFieldValueGetAsFixed(c_gameCatalogBehavior, "RagnarosEmpowerSulfurasCauterizeWoundsHeal", "Period", c_playerAny));
    lv_tokenValue = (lv_damageAmount / lv_periodCount);
    libGame_gf_ModifyTokenCount(FixedToInt(lv_tokenValue), "RagnarosCauterizeWoundsTokenCounter", lv_ragnarosUnit);
    UnitCreateEffectUnit(lv_ragnarosUnit, "RagnarosEmpowerSulfurasCauterizeWoundsUpdateSet", lv_ragnarosUnit);
    UnitCreateEffectUnit(lv_ragnarosUnit, "RagnarosEmpowerSulfurasCauterizeWoundsHealApplyBehavior", lv_ragnarosUnit);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHMaj_gt_HeroRagnarosEmpowerSulfurasCauterizeWounds_Init () {
    libHMaj_gt_HeroRagnarosEmpowerSulfurasCauterizeWounds = TriggerCreate("libHMaj_gt_HeroRagnarosEmpowerSulfurasCauterizeWounds_Func");
    TriggerEnable(libHMaj_gt_HeroRagnarosEmpowerSulfurasCauterizeWounds, false);
    TriggerAddEventUnitDamaged(libHMaj_gt_HeroRagnarosEmpowerSulfurasCauterizeWounds, null, c_unitDamageTypeAny, c_unitDamageEither, "RagnarosEmpowerSulfurasHeroicSplashDamage");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Ragnaros - Empower Sulfuras - Resilient Flame
//--------------------------------------------------------------------------------------------------
bool libHMaj_gt_HeroRagnarosEmpowerSulfurasResilientFlame_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_ragnarosUnit;

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

    // Conditions
    if (testConds) {
        if (!((UnitGetType(lv_ragnarosUnit) == "HeroRagnaros"))) {
            return false;
        }

        if (!((UnitBehaviorCount(lv_ragnarosUnit, "RagnaroResilientFlameCooldown") == 0))) {
            return false;
        }

        if (!((UnitBehaviorCount(lv_ragnarosUnit, "UsingVehicle") == 0))) {
            return false;
        }

        if (!((PlayerHasTalent(UnitGetOwner(lv_ragnarosUnit), "RagnarosResilientFlame") == true))) {
            return false;
        }

        if (!((UnitGetType(lv_ragnarosUnit) == "HeroRagnaros"))) {
            return false;
        }

        if (!((UnitHasBehaviorWithCategoryFlag(lv_ragnarosUnit, c_behaviorCategoryBuffUnstoppable) == false))) {
            return false;
        }

        if (!((UnitHasBehaviorWithCategoryFlag(lv_ragnarosUnit, c_behaviorCategoryInvulnerable) == false))) {
            return false;
        }

        if (!((UnitIsAlive(lv_ragnarosUnit) == true))) {
            return false;
        }
    }

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

    UnitCreateEffectUnit(lv_ragnarosUnit, "RagnarosResilientFlameProcSet", lv_ragnarosUnit);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHMaj_gt_HeroRagnarosEmpowerSulfurasResilientFlame_Init () {
    libHMaj_gt_HeroRagnarosEmpowerSulfurasResilientFlame = TriggerCreate("libHMaj_gt_HeroRagnarosEmpowerSulfurasResilientFlame_Func");
    TriggerEnable(libHMaj_gt_HeroRagnarosEmpowerSulfurasResilientFlame, false);
    TriggerAddEventUnitBehaviorChangeFromCategory(libHMaj_gt_HeroRagnarosEmpowerSulfurasResilientFlame, null, c_behaviorCategoryStun, c_unitBehaviorChangeCreate);
}

void libHMaj_InitTriggers () {
    libHMaj_gt_HeroRagnarosMoltenCoreHeroicModeCDReduction_Init();
    libHMaj_gt_HeroRagnarosMoltenCore_Init();
    libHMaj_gt_HeroRagnarosMoltenCoreEnd_Init();
    libHMaj_gt_HeroRagnarosMoltenCoreUpdateDurationBar_Init();
    libHMaj_gt_HeroRagnarosMoltenCoreCreateMarkers_Init();
    libHMaj_gt_HeroRagnarosMoltenCoreDestroyMarkers_Init();
    libHMaj_gt_HeroRagnarosMoltenCoreFullscreenOverlayOn_Init();
    libHMaj_gt_HeroRagnarosMoltenCoreFullscreenOverlayOff_Init();
    libHMaj_gt_HeroRagnarosMoltenCoreAbathurCloneSetCooldown_Init();
    libHMaj_gt_HeroRagnarosBigRagHealthGlobeRedirect_Init();
    libHMaj_gt_HeroRagnarosLavaWavePointTarget_Init();
    libHMaj_gt_HeroRagnarosSubmergeFullscreenOverlayOn_Init();
    libHMaj_gt_HeroRagnarosSubmergeFullscreenOverlayOff_Init();
    libHMaj_gt_HeroRagnarosGainsHeroic_Init();
    libHMaj_gt_HeroRagnarosEmpowerSulfurasCauterizeWounds_Init();
    libHMaj_gt_HeroRagnarosEmpowerSulfurasResilientFlame_Init();
}

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

void libHMaj_InitLib () {
    if (libHMaj_InitLib_completed) {
        return;
    }

    libHMaj_InitLib_completed = true;

    libHMaj_InitLibraries();
    libHMaj_InitVariables();
    libHMaj_InitTriggers();
}