mods/heromods/imperius.stormmod/base.stormdata/libhimp.galaxy

libhimp.galaxy
include "TriggerLibs/NativeLib"
include "TriggerLibs/HeroesLib"
include "TriggerLibs/GameLib"
include "TriggerLibs/AILib"
include "TriggerLibs/UILib"
include "TriggerLibs/GameDataHelperLib"

include "LibHIMP_h"

//--------------------------------------------------------------------------------------------------
// Library: Imperius
//--------------------------------------------------------------------------------------------------
// External Library Initialization
void libHIMP_InitLibraries () {
    libNtve_InitVariables();
    libCore_InitVariables();
    libGame_InitVariables();
    libAIAI_InitVariables();
    libUIUI_InitVariables();
    libGDHL_InitVariables();
}

// Variable Initialization
bool libHIMP_InitVariables_completed = false;

void libHIMP_InitVariables () {
    if (libHIMP_InitVariables_completed) {
        return;
    }

    libHIMP_InitVariables_completed = true;

}

// Functions
void libHIMP_gf_HeroImperiusIncrementHeroCountFunction () {
    // Automatic Variable Declarations
    // Implementation
    libHIMP_gv_heroImperiusTriggerRegistrationVariable += 1;
    if ((libHIMP_gv_heroImperiusTriggerRegistrationVariable == 1)) {
        TriggerEnable(libHIMP_gt_HeroImperiusCelestialChargeTargetUnitAlignment, true);
        TriggerEnable(libHIMP_gt_HeroImperiusCelestialChargeTimeStopHandler, true);
        TriggerEnable(libHIMP_gt_HeroImperiusWrathOfTheAngirisOverlayShow, true);
        TriggerEnable(libHIMP_gt_HeroImperiusWrathOfTheAngirisOverlayHide, true);
        TriggerEnable(libHIMP_gt_HeroImperiusWrathOfTheAngirisAIControl, true);
        TriggerEnable(libHIMP_gt_HeroImperiusWrathOfTheAngirisImperiusTeleport, true);
        TriggerEnable(libHIMP_gt_HeroImperiusWrathOfTheAngirisTargetTeleport, true);
        TriggerEnable(libHIMP_gt_HeroImperiusWrathOfTheAngirisValorousBrandStoreDuration, true);
        TriggerEnable(libHIMP_gt_HeroImperiusUnrelentingDescentFloatingText, true);
        TriggerEnable(libHIMP_gt_HeroImperiusCelestialChargeMoltenArmorOrderProc, true);
    }

}

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

    if ((libHIMP_gv_heroImperiusTriggerRegistrationVariable == 0)) {
        TriggerEnable(libHIMP_gt_HeroImperiusCelestialChargeTargetUnitAlignment, false);
        TriggerEnable(libHIMP_gt_HeroImperiusCelestialChargeTimeStopHandler, false);
        TriggerEnable(libHIMP_gt_HeroImperiusWrathOfTheAngirisOverlayShow, false);
        TriggerEnable(libHIMP_gt_HeroImperiusWrathOfTheAngirisOverlayHide, false);
        TriggerEnable(libHIMP_gt_HeroImperiusWrathOfTheAngirisAIControl, false);
        TriggerEnable(libHIMP_gt_HeroImperiusWrathOfTheAngirisImperiusTeleport, false);
        TriggerEnable(libHIMP_gt_HeroImperiusWrathOfTheAngirisTargetTeleport, false);
        TriggerEnable(libHIMP_gt_HeroImperiusWrathOfTheAngirisValorousBrandStoreDuration, false);
        TriggerEnable(libHIMP_gt_HeroImperiusUnrelentingDescentFloatingText, false);
        TriggerEnable(libHIMP_gt_HeroImperiusCelestialChargeMoltenArmorOrderProc, false);
    }

}

// Triggers
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Imperius - Celestial Charge - Target Unit Alignment
//--------------------------------------------------------------------------------------------------
bool libHIMP_gt_HeroImperiusCelestialChargeTargetUnitAlignment_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_imperiusUnit;
    fixed lv_imperiusUnitFacing;
    fixed lv_imperiusUnitFacing360;
    point lv_imperiusUnitPoint;
    unit lv_targetUnit;
    point lv_targetUnitPoint;
    fixed lv_iTDistance;
    fixed lv_relativeAngle;
    fixed lv_relativeAngle360;
    fixed lv_iTAngle;
    fixed lv_iADistance;
    fixed lv_minSkewerDistance;
    fixed lv_maxSkewerDistance;
    point lv_alignmentPoint;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_imperiusUnit = EventPlayerEffectUsedUnit(c_effectUnitCaster);
    lv_imperiusUnitFacing = UnitGetFacing(lv_imperiusUnit);
    lv_imperiusUnitPoint = UnitGetPosition(lv_imperiusUnit);
    lv_targetUnit = EventPlayerEffectUsedUnit(c_effectUnitTarget);
    lv_targetUnitPoint = UnitGetPosition(lv_targetUnit);

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

        if (!((UnitHasBehavior2(lv_targetUnit, "ImperiusCelestialChargeChannelStunDebuff") == true))) {
            return false;
        }
    }

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

    lv_minSkewerDistance = 1.5;
    lv_maxSkewerDistance = 4.5;
    lv_iTDistance = DistanceBetweenPoints(lv_imperiusUnitPoint, lv_targetUnitPoint);
    lv_relativeAngle = AngleBetweenPoints(lv_imperiusUnitPoint, lv_targetUnitPoint);
    if ((lv_imperiusUnitFacing >= 0.0)) {
        lv_imperiusUnitFacing360 = lv_imperiusUnitFacing;
    }
    else {
        lv_imperiusUnitFacing360 = (lv_imperiusUnitFacing + 360.0);
    }
    if ((lv_relativeAngle >= 0.0)) {
        lv_relativeAngle360 = lv_relativeAngle;
    }
    else {
        lv_relativeAngle360 = (lv_relativeAngle + 360.0);
    }
    lv_iTAngle = MinF(AbsF((lv_imperiusUnitFacing360 - lv_relativeAngle360)), AbsF(((lv_imperiusUnitFacing360 + lv_relativeAngle360) - 360.0)));
    lv_iADistance = (Cos(lv_iTAngle) * lv_iTDistance);
    if (((lv_iADistance >= lv_minSkewerDistance) && (lv_iADistance <= lv_maxSkewerDistance))) {
        lv_alignmentPoint = PointWithOffsetPolar(lv_imperiusUnitPoint, lv_iADistance, lv_imperiusUnitFacing);
    }
    else {
        if ((lv_iADistance > lv_maxSkewerDistance)) {
            lv_alignmentPoint = PointWithOffsetPolar(lv_imperiusUnitPoint, lv_maxSkewerDistance, lv_imperiusUnitFacing);
        }
        else {
            lv_alignmentPoint = PointWithOffsetPolar(lv_imperiusUnitPoint, lv_minSkewerDistance, lv_imperiusUnitFacing);
        }
    }
    UnitCreateEffectPoint(lv_targetUnit, "ImperiusCelestialChargeAlignmentLaunchMissile", lv_alignmentPoint);
    if (((UnitGetType(lv_targetUnit) == "HeroFalstad") || (UnitGetType(lv_targetUnit) == "HeroFaerieDragon"))) {
        while ((UnitHasBehavior2(lv_targetUnit, "ImperiusCelestialChargeChannelStunDebuff") == true)) {
            Wait(0.1873, c_timeGame);
        }
        libGDHL_gf_RestoreHeight(lv_targetUnit);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libHIMP_gt_HeroImperiusCelestialChargeTargetUnitAlignment_Init () {
    libHIMP_gt_HeroImperiusCelestialChargeTargetUnitAlignment = TriggerCreate("libHIMP_gt_HeroImperiusCelestialChargeTargetUnitAlignment_Func");
    TriggerEnable(libHIMP_gt_HeroImperiusCelestialChargeTargetUnitAlignment, false);
    TriggerAddEventPlayerEffectUsed(libHIMP_gt_HeroImperiusCelestialChargeTargetUnitAlignment, c_playerAny, "ImperiusCelestialChargeChannelStunDebuffApplyBehavior");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Imperius - Celestial Charge - Time Stop Handler
//--------------------------------------------------------------------------------------------------
bool libHIMP_gt_HeroImperiusCelestialChargeTimeStopHandler_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_targetUnit;
    unit lv_imperiusUnit;

    // Automatic Variable Declarations
    unitgroup autoB6DFFF06_g;
    int autoB6DFFF06_u;

    // Variable Initialization
    lv_targetUnit = EventUnit();

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

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

    if ((UnitHasBehavior2(lv_targetUnit, "ImperiusCelestialChargeCasterChannelBuff") == true)) {
        lv_imperiusUnit = lv_targetUnit;
        autoB6DFFF06_g = UnitGetTrackedUnitGroup(lv_imperiusUnit, "ImperiusCelestialChargeUnitTracker");
        autoB6DFFF06_u = UnitGroupCount(autoB6DFFF06_g, c_unitCountAll);
        for (;; autoB6DFFF06_u -= 1) {
            lv_targetUnit = UnitGroupUnitFromEnd(autoB6DFFF06_g, autoB6DFFF06_u);
            if (lv_targetUnit == null) { break; }
            if ((((UnitHasBehaviorWithCategoryFlag(lv_targetUnit, c_behaviorCategoryTimeStop) == true) && (UnitHasBehaviorWithCategoryFlag(lv_imperiusUnit, c_behaviorCategoryTimeStop) == false)) || ((UnitHasBehaviorWithCategoryFlag(lv_targetUnit, c_behaviorCategoryTimeStop) == false) && (UnitHasBehaviorWithCategoryFlag(lv_imperiusUnit, c_behaviorCategoryTimeStop) == true)))) {
                UnitBehaviorRemove(lv_targetUnit, "ImperiusCelestialChargeChannelStunDebuff", c_unitBehaviorCountAll);
            }

        }
    }

    if ((UnitHasBehavior2(lv_targetUnit, "ImperiusCelestialChargeChannelStunDebuff") == true)) {
        lv_imperiusUnit = UnitBehaviorEffectUnit(lv_targetUnit, "ImperiusCelestialChargeChannelStunDebuff", c_effectUnitCaster, 0);
        if ((((UnitHasBehaviorWithCategoryFlag(lv_targetUnit, c_behaviorCategoryTimeStop) == true) && (UnitHasBehaviorWithCategoryFlag(lv_imperiusUnit, c_behaviorCategoryTimeStop) == false)) || ((UnitHasBehaviorWithCategoryFlag(lv_targetUnit, c_behaviorCategoryTimeStop) == false) && (UnitHasBehaviorWithCategoryFlag(lv_imperiusUnit, c_behaviorCategoryTimeStop) == true)))) {
            UnitBehaviorRemove(lv_targetUnit, "ImperiusCelestialChargeChannelStunDebuff", c_unitBehaviorCountAll);
        }

    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libHIMP_gt_HeroImperiusCelestialChargeTimeStopHandler_Init () {
    libHIMP_gt_HeroImperiusCelestialChargeTimeStopHandler = TriggerCreate("libHIMP_gt_HeroImperiusCelestialChargeTimeStopHandler_Func");
    TriggerEnable(libHIMP_gt_HeroImperiusCelestialChargeTimeStopHandler, false);
    TriggerAddEventUnitBehaviorChangeFromCategory(libHIMP_gt_HeroImperiusCelestialChargeTimeStopHandler, null, c_behaviorCategoryTimeStop, c_unitBehaviorChangeCreate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Imperius - Wrath Of The Angiris - Overlay Show
//--------------------------------------------------------------------------------------------------
bool libHIMP_gt_HeroImperiusWrathOfTheAngirisOverlayShow_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_wrathOfTheAngirisUnit;
    int lv_wrathOfTheAngirisPlayer;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_wrathOfTheAngirisUnit = EventUnit();
    lv_wrathOfTheAngirisPlayer = UnitGetOwner(lv_wrathOfTheAngirisUnit);

    // Conditions
    if (testConds) {
        if (!((UnitHasBehavior2(lv_wrathOfTheAngirisUnit, "HeroGenericIgnoreFullscreenOverlay") == false))) {
            return false;
        }

        if (!((lv_wrathOfTheAngirisUnit == libGame_gv_players[lv_wrathOfTheAngirisPlayer].lv_heroUnit))) {
            return false;
        }
    }

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

    libUIUI_gf_FullscreenOverlayAddItemForPlayer(lv_wrathOfTheAngirisPlayer, libUIUI_ge_FullscreenOverlayPriorities_Stasis, "Cutscenes\\GameUI_ImperiusOverlay.StormCutscene", EventUnitBehavior());
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHIMP_gt_HeroImperiusWrathOfTheAngirisOverlayShow_Init () {
    libHIMP_gt_HeroImperiusWrathOfTheAngirisOverlayShow = TriggerCreate("libHIMP_gt_HeroImperiusWrathOfTheAngirisOverlayShow_Func");
    TriggerEnable(libHIMP_gt_HeroImperiusWrathOfTheAngirisOverlayShow, false);
    TriggerAddEventUnitBehaviorChange(libHIMP_gt_HeroImperiusWrathOfTheAngirisOverlayShow, null, "ImperiusWrathOfTheAngirisTargetRemovedStasis", c_unitBehaviorChangeActivate);
    TriggerAddEventUnitBehaviorChange(libHIMP_gt_HeroImperiusWrathOfTheAngirisOverlayShow, null, "ImperiusWrathOfTheAngirisCasterRemovedStasis", c_unitBehaviorChangeActivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Imperius - Wrath Of The Angiris - Overlay Hide
//--------------------------------------------------------------------------------------------------
bool libHIMP_gt_HeroImperiusWrathOfTheAngirisOverlayHide_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_wrathOfTheAngirisUnit;
    int lv_wrathOfTheAngirisPlayer;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_wrathOfTheAngirisUnit = EventUnit();
    lv_wrathOfTheAngirisPlayer = UnitGetOwner(lv_wrathOfTheAngirisUnit);

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

    Wait(0.125, c_timeGame);
    libUIUI_gf_FullscreenOverlayRemoveItemFromQueueForPlayer(lv_wrathOfTheAngirisPlayer, "Cutscenes\\GameUI_ImperiusOverlay.StormCutscene", EventUnitBehavior());
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHIMP_gt_HeroImperiusWrathOfTheAngirisOverlayHide_Init () {
    libHIMP_gt_HeroImperiusWrathOfTheAngirisOverlayHide = TriggerCreate("libHIMP_gt_HeroImperiusWrathOfTheAngirisOverlayHide_Func");
    TriggerEnable(libHIMP_gt_HeroImperiusWrathOfTheAngirisOverlayHide, false);
    TriggerAddEventUnitBehaviorChange(libHIMP_gt_HeroImperiusWrathOfTheAngirisOverlayHide, null, "ImperiusWrathOfTheAngirisTargetRemovedStasis", c_unitBehaviorChangeDeactivate);
    TriggerAddEventUnitBehaviorChange(libHIMP_gt_HeroImperiusWrathOfTheAngirisOverlayHide, null, "ImperiusWrathOfTheAngirisCasterRemovedStasis", c_unitBehaviorChangeDeactivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Imperius - Wrath Of The Angiris - AI Control
//--------------------------------------------------------------------------------------------------
bool libHIMP_gt_HeroImperiusWrathOfTheAngirisAIControl_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_wrathOfTheAngirisCursorUnit;
    int lv_imperiusPlayer;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_wrathOfTheAngirisCursorUnit = EventUnitCreatedUnit();
    lv_imperiusPlayer = UnitGetOwner(lv_wrathOfTheAngirisCursorUnit);

    // Conditions
    if (testConds) {
        if (!((libAIAI_gf_HeroAIIsAIEnabledForPlayer(lv_imperiusPlayer) == true))) {
            return false;
        }

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

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

    UnitCreateAIThinkTree(lv_wrathOfTheAngirisCursorUnit);
    while ((libAIAI_gf_HeroAIIsAIEnabledForPlayer(lv_imperiusPlayer) == true) && (UnitIsAlive(lv_wrathOfTheAngirisCursorUnit) == true)) {
        Wait(0.5, c_timeGame);
    }
    UnitDestroyAIThinkTree(lv_wrathOfTheAngirisCursorUnit);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHIMP_gt_HeroImperiusWrathOfTheAngirisAIControl_Init () {
    libHIMP_gt_HeroImperiusWrathOfTheAngirisAIControl = TriggerCreate("libHIMP_gt_HeroImperiusWrathOfTheAngirisAIControl_Func");
    TriggerEnable(libHIMP_gt_HeroImperiusWrathOfTheAngirisAIControl, false);
    TriggerAddEventUnitCreated(libHIMP_gt_HeroImperiusWrathOfTheAngirisAIControl, null, null, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Imperius - Wrath Of The Angiris - Imperius Teleport
//--------------------------------------------------------------------------------------------------
bool libHIMP_gt_HeroImperiusWrathOfTheAngirisImperiusTeleport_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_wrathOfTheAngirisCursorUnit;
    int lv_wrathOfTheAngirisImperiusPlayer;
    unit lv_wrathOfTheAngirisImperiusUnit;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_wrathOfTheAngirisCursorUnit = EventUnit();
    lv_wrathOfTheAngirisImperiusPlayer = UnitGetOwner(lv_wrathOfTheAngirisCursorUnit);
    lv_wrathOfTheAngirisImperiusUnit = libGame_gv_players[lv_wrathOfTheAngirisImperiusPlayer].lv_heroUnit;

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

    while ((UnitIsAlive(lv_wrathOfTheAngirisCursorUnit) == true) && (UnitHasBehavior2(lv_wrathOfTheAngirisImperiusUnit, "ImperiusWrathOfTheAngirisCasterRemovedStasis") == true)) {
        UnitSetPosition(lv_wrathOfTheAngirisImperiusUnit, UnitGetPosition(lv_wrathOfTheAngirisCursorUnit), true);
        Wait(0.0625, c_timeGame);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHIMP_gt_HeroImperiusWrathOfTheAngirisImperiusTeleport_Init () {
    libHIMP_gt_HeroImperiusWrathOfTheAngirisImperiusTeleport = TriggerCreate("libHIMP_gt_HeroImperiusWrathOfTheAngirisImperiusTeleport_Func");
    TriggerEnable(libHIMP_gt_HeroImperiusWrathOfTheAngirisImperiusTeleport, false);
    TriggerAddEventUnitBehaviorChange(libHIMP_gt_HeroImperiusWrathOfTheAngirisImperiusTeleport, null, "ImperiusWrathOfTheAngirisCursorUnitTimedLife", c_unitBehaviorChangeActivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Imperius - Wrath Of The Angiris - Target Teleport
//--------------------------------------------------------------------------------------------------
bool libHIMP_gt_HeroImperiusWrathOfTheAngirisTargetTeleport_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_wrathOfTheAngirisTargetUnit;
    int lv_wrathOfTheAngirisTargetPlayer;
    unit lv_wrathOfTheAngirisImperiusUnit;
    int lv_wrathOfTheAngirisImperiusPlayer;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_wrathOfTheAngirisTargetUnit = EventUnit();
    lv_wrathOfTheAngirisTargetPlayer = UnitGetOwner(lv_wrathOfTheAngirisTargetUnit);
    lv_wrathOfTheAngirisImperiusUnit = UnitBehaviorEffectUnit(lv_wrathOfTheAngirisTargetUnit, "ImperiusWrathOfTheAngirisTargetRemovedStasis", c_effectUnitCaster, 0);
    lv_wrathOfTheAngirisImperiusPlayer = UnitGetOwner(lv_wrathOfTheAngirisImperiusUnit);

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

    if ((UnitHasBehavior2(lv_wrathOfTheAngirisTargetUnit, "ImperiusWrathOfTheAngirisTargetRemovedStasis") == true) && (lv_wrathOfTheAngirisTargetUnit == libGame_gv_players[lv_wrathOfTheAngirisTargetPlayer].lv_heroUnit)) {
        libGame_gf_PlayerHeroDisplacementCameraLock(lv_wrathOfTheAngirisTargetUnit, "ImperiusWrathOfTheAngirisTargetRemovedStasis");
    }

    while ((UnitHasBehavior2(lv_wrathOfTheAngirisTargetUnit, "ImperiusWrathOfTheAngirisTargetRemovedStasis") == true) && (UnitBehaviorDuration(lv_wrathOfTheAngirisTargetUnit, "ImperiusWrathOfTheAngirisTargetRemovedStasis") > 0.125)) {
        UnitSetPosition(lv_wrathOfTheAngirisTargetUnit, UnitGetPosition(lv_wrathOfTheAngirisImperiusUnit), true);
        Wait(0.0625, c_timeGame);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHIMP_gt_HeroImperiusWrathOfTheAngirisTargetTeleport_Init () {
    libHIMP_gt_HeroImperiusWrathOfTheAngirisTargetTeleport = TriggerCreate("libHIMP_gt_HeroImperiusWrathOfTheAngirisTargetTeleport_Func");
    TriggerEnable(libHIMP_gt_HeroImperiusWrathOfTheAngirisTargetTeleport, false);
    TriggerAddEventUnitBehaviorChange(libHIMP_gt_HeroImperiusWrathOfTheAngirisTargetTeleport, null, "ImperiusWrathOfTheAngirisTargetRemovedStasis", c_unitBehaviorChangeActivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Imperius - Wrath Of The Angiris - Valorouos Brand Store Duration
//--------------------------------------------------------------------------------------------------
bool libHIMP_gt_HeroImperiusWrathOfTheAngirisValorousBrandStoreDuration_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_wrathoftheAngirisPlayer;
    int lv_valorousBrandIterator;
    int lv_valorousBrandStackCount;
    fixed lv_valorousBrandIteratorDuration;
    string lv_behaviorLink;
    string lv_behaviorApplySetLink;
    string lv_behaviorApplyLink;

    // Automatic Variable Declarations
    int auto5288808B_ae;
    const int auto5288808B_ai = 1;
    int auto6B893CD3_ae;
    const int auto6B893CD3_ai = 1;
    int autoC8D28ECB_ae;
    const int autoC8D28ECB_ai = 1;

    // Variable Initialization
    lv_wrathoftheAngirisPlayer = UnitBehaviorEffectPlayer(EventUnit(), EventUnitBehavior(), c_effectPlayerCaster, 0);

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

    lv_behaviorLink = "ImperiusValorousBrandCelestialChargeComboPointBehavior";
    lv_behaviorApplySetLink = "ImperiusValorousBrandApplyCelestialChargeWrathOfTheAngirisMarkSet";
    lv_behaviorApplyLink = "ImperiusValorousBrandComboPointCelestialChargeWrathOfTheAngirisApplyBehavior";
    if ((UnitHasBehavior2(EventUnit(), lv_behaviorLink) == true)) {
        lv_valorousBrandStackCount = UnitBehaviorCount(EventUnit(), lv_behaviorLink);
        lv_valorousBrandIterator = 0;
        auto5288808B_ae = lv_valorousBrandStackCount;
        lv_valorousBrandIterator = 0;
        for ( ; ( (auto5288808B_ai >= 0 && lv_valorousBrandIterator <= auto5288808B_ae) || (auto5288808B_ai < 0 && lv_valorousBrandIterator >= auto5288808B_ae) ) ; lv_valorousBrandIterator += auto5288808B_ai ) {
            if ((UnitBehaviorEffectPlayer(EventUnit(), lv_behaviorLink, c_effectPlayerCaster, lv_valorousBrandIterator) == lv_wrathoftheAngirisPlayer)) {
                lv_valorousBrandIteratorDuration = UnitBehaviorDuration(EventUnit(), lv_behaviorLink);
                if ((lv_valorousBrandIteratorDuration >= 1.0)) {
                    CatalogFieldValueSetFixed(c_gameCatalogEffect, lv_behaviorApplySetLink, "Chance", lv_wrathoftheAngirisPlayer, 1.0);
                    CatalogFieldValueSetFixed(c_gameCatalogEffect, lv_behaviorApplyLink, "Duration", lv_wrathoftheAngirisPlayer, (lv_valorousBrandIteratorDuration - 0.625));
                    break;
                }
                else {
                    CatalogFieldValueSetFixed(c_gameCatalogEffect, lv_behaviorApplySetLink, "Chance", lv_wrathoftheAngirisPlayer, 0.0);
                    break;
                }
                if ((lv_valorousBrandIteratorDuration == lv_valorousBrandStackCount)) {
                    CatalogFieldValueSetFixed(c_gameCatalogEffect, lv_behaviorApplySetLink, "Chance", lv_wrathoftheAngirisPlayer, 0.0);
                }

            }
            else {
                CatalogFieldValueSetFixed(c_gameCatalogEffect, lv_behaviorApplySetLink, "Chance", lv_wrathoftheAngirisPlayer, 0.0);
            }
        }
    }
    else {
        CatalogFieldValueSetFixed(c_gameCatalogEffect, lv_behaviorApplySetLink, "Chance", lv_wrathoftheAngirisPlayer, 0.0);
    }
    lv_behaviorLink = "ImperiusValorousBrandSolarionsFireComboPointBehavior";
    lv_behaviorApplySetLink = "ImperiusValorousBrandApplySolarionsFireWrathOfTheAngirisMarkSet";
    lv_behaviorApplyLink = "ImperiusValorousBrandComboPointSolarionsFireWrathOfTheAngirisApplyBehavior";
    if ((UnitHasBehavior2(EventUnit(), lv_behaviorLink) == true)) {
        lv_valorousBrandStackCount = UnitBehaviorCount(EventUnit(), lv_behaviorLink);
        lv_valorousBrandIterator = 0;
        auto6B893CD3_ae = lv_valorousBrandStackCount;
        lv_valorousBrandIterator = 0;
        for ( ; ( (auto6B893CD3_ai >= 0 && lv_valorousBrandIterator <= auto6B893CD3_ae) || (auto6B893CD3_ai < 0 && lv_valorousBrandIterator >= auto6B893CD3_ae) ) ; lv_valorousBrandIterator += auto6B893CD3_ai ) {
            if ((UnitBehaviorEffectPlayer(EventUnit(), lv_behaviorLink, c_effectPlayerCaster, lv_valorousBrandIterator) == lv_wrathoftheAngirisPlayer)) {
                lv_valorousBrandIteratorDuration = UnitBehaviorDuration(EventUnit(), lv_behaviorLink);
                if ((lv_valorousBrandIteratorDuration >= 1.0)) {
                    CatalogFieldValueSetFixed(c_gameCatalogEffect, lv_behaviorApplySetLink, "Chance", lv_wrathoftheAngirisPlayer, 1.0);
                    CatalogFieldValueSetFixed(c_gameCatalogEffect, lv_behaviorApplyLink, "Duration", lv_wrathoftheAngirisPlayer, (lv_valorousBrandIteratorDuration - 0.625));
                    break;
                }
                else {
                    CatalogFieldValueSetFixed(c_gameCatalogEffect, lv_behaviorApplySetLink, "Chance", lv_wrathoftheAngirisPlayer, 0.0);
                    break;
                }
                if ((lv_valorousBrandIteratorDuration == lv_valorousBrandStackCount)) {
                    CatalogFieldValueSetFixed(c_gameCatalogEffect, lv_behaviorApplySetLink, "Chance", lv_wrathoftheAngirisPlayer, 0.0);
                }

            }
            else {
                CatalogFieldValueSetFixed(c_gameCatalogEffect, lv_behaviorApplySetLink, "Chance", lv_wrathoftheAngirisPlayer, 0.0);
            }
        }
    }
    else {
        CatalogFieldValueSetFixed(c_gameCatalogEffect, lv_behaviorApplySetLink, "Chance", lv_wrathoftheAngirisPlayer, 0.0);
    }
    lv_behaviorLink = "ImperiusValorousBrandMoltenArmorComboPointBehavior";
    lv_behaviorApplySetLink = "ImperiusValorousBrandApplyMoltenArmorWrathOfTheAngirisMarkSet";
    lv_behaviorApplyLink = "ImperiusValorousBrandComboPointMoltenArmorWrathOfTheAngirisApplyBehavior";
    if ((UnitHasBehavior2(EventUnit(), lv_behaviorLink) == true)) {
        lv_valorousBrandStackCount = UnitBehaviorCount(EventUnit(), lv_behaviorLink);
        lv_valorousBrandIterator = 0;
        autoC8D28ECB_ae = lv_valorousBrandStackCount;
        lv_valorousBrandIterator = 0;
        for ( ; ( (autoC8D28ECB_ai >= 0 && lv_valorousBrandIterator <= autoC8D28ECB_ae) || (autoC8D28ECB_ai < 0 && lv_valorousBrandIterator >= autoC8D28ECB_ae) ) ; lv_valorousBrandIterator += autoC8D28ECB_ai ) {
            if ((UnitBehaviorEffectPlayer(EventUnit(), lv_behaviorLink, c_effectPlayerCaster, lv_valorousBrandIterator) == lv_wrathoftheAngirisPlayer)) {
                lv_valorousBrandIteratorDuration = UnitBehaviorDuration(EventUnit(), lv_behaviorLink);
                if ((lv_valorousBrandIteratorDuration >= 1.0)) {
                    CatalogFieldValueSetFixed(c_gameCatalogEffect, lv_behaviorApplySetLink, "Chance", lv_wrathoftheAngirisPlayer, 1.0);
                    CatalogFieldValueSetFixed(c_gameCatalogEffect, lv_behaviorApplyLink, "Duration", lv_wrathoftheAngirisPlayer, (lv_valorousBrandIteratorDuration - 0.625));
                    break;
                }
                else {
                    CatalogFieldValueSetFixed(c_gameCatalogEffect, lv_behaviorApplySetLink, "Chance", lv_wrathoftheAngirisPlayer, 0.0);
                    break;
                }
                if ((lv_valorousBrandIteratorDuration == lv_valorousBrandStackCount)) {
                    CatalogFieldValueSetFixed(c_gameCatalogEffect, lv_behaviorApplySetLink, "Chance", lv_wrathoftheAngirisPlayer, 0.0);
                }

            }
            else {
                CatalogFieldValueSetFixed(c_gameCatalogEffect, lv_behaviorApplySetLink, "Chance", lv_wrathoftheAngirisPlayer, 0.0);
            }
        }
    }
    else {
        CatalogFieldValueSetFixed(c_gameCatalogEffect, lv_behaviorApplySetLink, "Chance", lv_wrathoftheAngirisPlayer, 0.0);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHIMP_gt_HeroImperiusWrathOfTheAngirisValorousBrandStoreDuration_Init () {
    libHIMP_gt_HeroImperiusWrathOfTheAngirisValorousBrandStoreDuration = TriggerCreate("libHIMP_gt_HeroImperiusWrathOfTheAngirisValorousBrandStoreDuration_Func");
    TriggerEnable(libHIMP_gt_HeroImperiusWrathOfTheAngirisValorousBrandStoreDuration, false);
    TriggerAddEventUnitBehaviorChange(libHIMP_gt_HeroImperiusWrathOfTheAngirisValorousBrandStoreDuration, null, "ImperiusWrathOfTheAngirisTargetImpactStasis", c_unitBehaviorChangeActivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Imperius - Unrelenting Descent Floating Text
//--------------------------------------------------------------------------------------------------
bool libHIMP_gt_HeroImperiusUnrelentingDescentFloatingText_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_imperiusUnit;
    int lv_imperiusPlayer;
    int lv_amountHealed;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_imperiusUnit = EventPlayerEffectUsedUnit(c_effectUnitCaster);
    lv_imperiusPlayer = EventPlayerEffectUsedUnitOwner(c_effectPlayerCaster);
    lv_amountHealed = EventPlayerEffectUsedAmountInt(c_effectAmountHealed, false);

    // Conditions
    if (testConds) {
        if (!((lv_imperiusPlayer <= libCore_gv_bALMaxPlayers))) {
            return false;
        }

        if (!((lv_imperiusPlayer != 0))) {
            return false;
        }

        if (!((lv_amountHealed != 0))) {
            return false;
        }
    }

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

    Wait(0.0625, c_timeGame);
    FloatingCombatElementCreateTextAtUnit(PlayerGroupSingle(lv_imperiusPlayer), "FloatingCombatElements/FloatingCombatNormalAmountReceived", "HealState", lv_imperiusUnit, IntToText(lv_amountHealed), libNtve_gv_FloatingCombatTextAutoRandomSeed);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHIMP_gt_HeroImperiusUnrelentingDescentFloatingText_Init () {
    libHIMP_gt_HeroImperiusUnrelentingDescentFloatingText = TriggerCreate("libHIMP_gt_HeroImperiusUnrelentingDescentFloatingText_Func");
    TriggerEnable(libHIMP_gt_HeroImperiusUnrelentingDescentFloatingText, false);
    TriggerAddEventPlayerEffectUsed(libHIMP_gt_HeroImperiusUnrelentingDescentFloatingText, c_playerAny, "ImperiusWrathOfTheAngirisUnrelentingDescentCreateHealer");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Imperius - Celestial Charge - Molten Armor Order Proc
//--------------------------------------------------------------------------------------------------
bool libHIMP_gt_HeroImperiusCelestialChargeMoltenArmorOrderProc_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 (!((libHIMP_gv_heroImperiusCelestialChargeMoltenArmorOrderProcBoolean[lv_player] == false))) {
            return false;
        }

        if (!((lv_player > 0))) {
            return false;
        }

        if (!((lv_player <= libCore_gv_bALMaxPlayers))) {
            return false;
        }

        if (!((UnitFilterMatch(lv_unit, lv_player, UnitFilter(0, 0, (1 << c_targetFilterMissile) | (1 << c_targetFilterItem), (1 << (c_targetFilterStasis - 32)) | (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)) | (1 << (c_targetFilterSilenced - 32)))) == true))) {
            return false;
        }

        if (!((UnitBehaviorCount(lv_unit, "ImperiusCelestialChargeCasterMarker") == 1))) {
            return false;
        }
    }

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

    libHIMP_gv_heroImperiusCelestialChargeMoltenArmorOrderProcBoolean[lv_player] = true;
    UnitCreateEffectUnitWithSource(lv_unit, "ImperiusMoltenArmorCelestialChargeInitialSet", lv_unit, c_gameCatalogAbil, "ImperiusMoltenArmor");
    Wait(0.0625, c_timeGame);
    libHIMP_gv_heroImperiusCelestialChargeMoltenArmorOrderProcBoolean[lv_player] = false;
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHIMP_gt_HeroImperiusCelestialChargeMoltenArmorOrderProc_Init () {
    libHIMP_gt_HeroImperiusCelestialChargeMoltenArmorOrderProc = TriggerCreate("libHIMP_gt_HeroImperiusCelestialChargeMoltenArmorOrderProc_Func");
    TriggerEnable(libHIMP_gt_HeroImperiusCelestialChargeMoltenArmorOrderProc, false);
    TriggerAddEventUnitOrder(libHIMP_gt_HeroImperiusCelestialChargeMoltenArmorOrderProc, null, AbilityCommand("ImperiusMoltenArmor", 0));
}

void libHIMP_InitTriggers () {
    libHIMP_gt_HeroImperiusCelestialChargeTargetUnitAlignment_Init();
    libHIMP_gt_HeroImperiusCelestialChargeTimeStopHandler_Init();
    libHIMP_gt_HeroImperiusWrathOfTheAngirisOverlayShow_Init();
    libHIMP_gt_HeroImperiusWrathOfTheAngirisOverlayHide_Init();
    libHIMP_gt_HeroImperiusWrathOfTheAngirisAIControl_Init();
    libHIMP_gt_HeroImperiusWrathOfTheAngirisImperiusTeleport_Init();
    libHIMP_gt_HeroImperiusWrathOfTheAngirisTargetTeleport_Init();
    libHIMP_gt_HeroImperiusWrathOfTheAngirisValorousBrandStoreDuration_Init();
    libHIMP_gt_HeroImperiusUnrelentingDescentFloatingText_Init();
    libHIMP_gt_HeroImperiusCelestialChargeMoltenArmorOrderProc_Init();
}

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

void libHIMP_InitLib () {
    if (libHIMP_InitLib_completed) {
        return;
    }

    libHIMP_InitLib_completed = true;

    libHIMP_InitLibraries();
    libHIMP_InitVariables();
    libHIMP_InitTriggers();
}