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_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);

        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);

        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

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

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);

    UnitModifyCooldown(lv_regularRagnarosUnit, "Abil/RagnarosMoltenCore", CatalogFieldValueGetAsInt(c_gameCatalogAbil, "RagnarosMoltenCore", "Cost.Cooldown.TimeUse", lv_ragnarosPlayer), 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_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();

}