mods/heromods/alarak.stormmod/base.stormdata/libhala.galaxy

libhala.galaxy
include "TriggerLibs/NativeLib"
include "TriggerLibs/HeroesLib"
include "TriggerLibs/GameLib"
include "TriggerLibs/UILib"

include "LibHALA_h"

//--------------------------------------------------------------------------------------------------
// Library: Alarak
//--------------------------------------------------------------------------------------------------
// External Library Initialization
void libHALA_InitLibraries () {
    libNtve_InitVariables();
    libCore_InitVariables();
    libGame_InitVariables();
    libUIUI_InitVariables();
}

// Variable Initialization
bool libHALA_InitVariables_completed = false;

void libHALA_InitVariables () {
    int init_i;

    if (libHALA_InitVariables_completed) {
        return;
    }

    libHALA_InitVariables_completed = true;

    for (init_i = 0; init_i <= libCore_gv_bALMaxPlayers; init_i += 1) {
        libHALA_gv_heroAlarakCounterStrikeUnitGroup[init_i] = UnitGroupEmpty();
    }
    libHALA_gv_alarakUI.lv_mainPanel = c_invalidDialogControlId;
    libHALA_gv_alarakUI.lv_sadismProgressBar = c_invalidDialogControlId;
    libHALA_gv_alarakUI.lv_sadismPercentageLabel = c_invalidDialogControlId;
    libHALA_gv_alarakUI.lv_sadismExtraGlowImage = c_invalidDialogControlId;
}

// Functions
void libHALA_gf_HeroAlarakIncrementHeroCountFunction () {
    // Automatic Variable Declarations
    // Implementation
    libHALA_gv_heroAlarakTriggerRegistrationVariable += 1;
    if ((libHALA_gv_heroAlarakTriggerRegistrationVariable == 1)) {
        TriggerEnable(libHALA_gt_HeroAlarakHeroSpawned, true);
        TriggerEnable(libHALA_gt_HeroAlarakCounterStrikeSetFacing, true);
        TriggerEnable(libHALA_gt_HeroAlarakCounterStrikeDamageResponseProc, true);
        TriggerEnable(libHALA_gt_HeroAlarakCounterStrikeUnitGroupReset, true);
        TriggerEnable(libHALA_gt_HeroAlarakPureMaliceAllyDeathProc, true);
        TriggerEnable(libHALA_gt_HeroAlarakSadismTakedownBonusProc, true);
        TriggerEnable(libHALA_gt_HeroAlarakDeadlyChargeTurnTriggersOn, true);
        TriggerEnable(libHALA_gt_HeroAlarakDeadlyChargeTurnTriggersOff, true);
        TriggerEnable(libHALA_gt_HeroAlarakDeadlyChargeCasterClicked, true);
        TriggerEnable(libHALA_gt_HeroAlarakDeadlyChargeExecuteEffect, true);
        TriggerEnable(libHALA_gt_HeroAlarakSadismRespecReset, true);
        TriggerEnable(libHALA_gt_HeroAlarakCounterStrikeProtectedOnOff, true);
        TriggerEnable(libHALA_gt_HeroAlarakSadismTokensModified, true);
        TriggerEnable(libHALA_gt_HeroAlarakSurgeActorMessages, true);
        TriggerEnable(libHALA_gt_HeroAlarakRiteofRakShirFXDebuffAndCasterReveal, true);
        TriggerEnable(libHALA_gt_HeroAlarakRiteofRakShirTransportRedirect, true);
        TriggerEnable(libHALA_gt_HeroAlarakRiteofRakShirTargetDies, true);
    }

}

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

    if ((libHALA_gv_heroAlarakTriggerRegistrationVariable == 0)) {
        TriggerEnable(libHALA_gt_HeroAlarakHeroSpawned, false);
        TriggerEnable(libHALA_gt_HeroAlarakCounterStrikeSetFacing, false);
        TriggerEnable(libHALA_gt_HeroAlarakCounterStrikeDamageResponseProc, false);
        TriggerEnable(libHALA_gt_HeroAlarakCounterStrikeUnitGroupReset, false);
        TriggerEnable(libHALA_gt_HeroAlarakPureMaliceAllyDeathProc, false);
        TriggerEnable(libHALA_gt_HeroAlarakSadismTakedownBonusProc, false);
        TriggerEnable(libHALA_gt_HeroAlarakDeadlyChargeTurnTriggersOn, false);
        TriggerEnable(libHALA_gt_HeroAlarakDeadlyChargeTurnTriggersOff, false);
        TriggerEnable(libHALA_gt_HeroAlarakDeadlyChargeCasterClicked, false);
        TriggerEnable(libHALA_gt_HeroAlarakDeadlyChargeExecuteEffect, false);
        TriggerEnable(libHALA_gt_HeroAlarakSadismRespecReset, false);
        TriggerEnable(libHALA_gt_HeroAlarakCounterStrikeProtectedOnOff, false);
        TriggerEnable(libHALA_gt_HeroAlarakSadismTokensModified, false);
        TriggerEnable(libHALA_gt_HeroAlarakSurgeActorMessages, false);
        TriggerEnable(libHALA_gt_HeroAlarakRiteofRakShirFXDebuffAndCasterReveal, false);
        TriggerEnable(libHALA_gt_HeroAlarakRiteofRakShirTransportRedirect, false);
        TriggerEnable(libHALA_gt_HeroAlarakRiteofRakShirTargetDies, false);
    }

}

void libHALA_gf_HeroAlarakUpdateSadismUI (int lp_player) {
    // Variable Declarations
    int lv_player;
    unit lv_alarakUnit;
    fixed lv_sadismValue;
    string lv_sadismString;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_alarakUnit = libGame_gv_players[lp_player].lv_heroUnit;
    lv_sadismString = "";

    // Implementation
    lv_sadismValue = (StringToFixed(CatalogFieldValueGet(c_gameCatalogAccumulator, "AlarakSadismAccumulator", "Scale", lp_player)) * UnitGetTokenCount(lv_alarakUnit, CatalogFieldValueGet(c_gameCatalogAccumulator, "AlarakSadismAccumulator", "TokenId", lp_player)));
    lv_sadismValue = (lv_sadismValue + (StringToFixed(CatalogFieldValueGet(c_gameCatalogAccumulator, "AlarakSadismPureMaliceAccumulator", "Scale", lp_player)) * UnitGetTokenCount(lv_alarakUnit, CatalogFieldValueGet(c_gameCatalogAccumulator, "AlarakSadismPureMaliceAccumulator", "TokenId", lp_player))));
    lv_sadismValue = (lv_sadismValue * 100.0);
    if ((lv_sadismValue > 100.0)) {
        if ((lv_sadismValue > 100.0) && (lv_sadismValue < 109.0)) {
            DialogControlSendAnimationEvent(libHALA_gv_alarakUI.lv_sadismExtraGlowImage, libCore_gv_playerGroupFromPlayer[lp_player], "PureMaliceStack1");
        }

        if ((lv_sadismValue > 109.0) && (lv_sadismValue < 117.0)) {
            DialogControlSendAnimationEvent(libHALA_gv_alarakUI.lv_sadismExtraGlowImage, libCore_gv_playerGroupFromPlayer[lp_player], "PureMaliceStack2");
        }

        if ((lv_sadismValue > 117.0) && (lv_sadismValue < 125.0)) {
            DialogControlSendAnimationEvent(libHALA_gv_alarakUI.lv_sadismExtraGlowImage, libCore_gv_playerGroupFromPlayer[lp_player], "PureMaliceStack3");
        }

        if ((lv_sadismValue > 125.0) && (lv_sadismValue < 133.0)) {
            DialogControlSendAnimationEvent(libHALA_gv_alarakUI.lv_sadismExtraGlowImage, libCore_gv_playerGroupFromPlayer[lp_player], "PureMaliceStack4");
        }

        if ((lv_sadismValue > 133.0)) {
            DialogControlSendAnimationEvent(libHALA_gv_alarakUI.lv_sadismExtraGlowImage, libCore_gv_playerGroupFromPlayer[lp_player], "PureMaliceStack5");
        }

    }
    else {
        DialogControlSetVisible(libHALA_gv_alarakUI.lv_sadismExtraGlowImage, libCore_gv_playerGroupFromPlayer[lp_player], false);
    }
    libNtve_gf_SetDialogItemCurrentValue(libHALA_gv_alarakUI.lv_sadismProgressBar, FixedToInt(lv_sadismValue), libCore_gv_playerGroupFromPlayer[lp_player]);
    libNtve_gf_SetDialogItemText(libHALA_gv_alarakUI.lv_sadismPercentageLabel, FixedToText(lv_sadismValue, 0), libCore_gv_playerGroupFromPlayer[lp_player]);
}

// Triggers
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Alarak - Hero Spawned
//--------------------------------------------------------------------------------------------------
bool libHALA_gt_HeroAlarakHeroSpawned_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_player;

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

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

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

    TriggerAddEventMouseClicked(libHALA_gt_HeroAlarakDeadlyChargeCasterClicked, lv_player, c_mouseButtonLeft, true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHALA_gt_HeroAlarakHeroSpawned_Init () {
    libHALA_gt_HeroAlarakHeroSpawned = TriggerCreate("libHALA_gt_HeroAlarakHeroSpawned_Func");
    TriggerEnable(libHALA_gt_HeroAlarakHeroSpawned, false);
    libGame_gf_HeroSpawn(libHALA_gt_HeroAlarakHeroSpawned);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Alarak - Deadly Charge - Turn Triggers On
//--------------------------------------------------------------------------------------------------
bool libHALA_gt_HeroAlarakDeadlyChargeTurnTriggersOn_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_player;

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

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

    libHALA_gv_heroAlarakIsPlayerCastingDeadlyCharge[lv_player] = true;
    libHALA_gv_heroAlarakActiveDeadlyChargeCasters += 1;
    TriggerEnable(libHALA_gt_HeroAlarakDeadlyChargeCasterClicked, true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHALA_gt_HeroAlarakDeadlyChargeTurnTriggersOn_Init () {
    libHALA_gt_HeroAlarakDeadlyChargeTurnTriggersOn = TriggerCreate("libHALA_gt_HeroAlarakDeadlyChargeTurnTriggersOn_Func");
    TriggerEnable(libHALA_gt_HeroAlarakDeadlyChargeTurnTriggersOn, false);
    TriggerAddEventUnitBehaviorChange(libHALA_gt_HeroAlarakDeadlyChargeTurnTriggersOn, null, "AlarakDeadlyChargeChanneling", c_unitBehaviorChangeCreate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Alarak - Deadly Charge - Turn Triggers Off
//--------------------------------------------------------------------------------------------------
bool libHALA_gt_HeroAlarakDeadlyChargeTurnTriggersOff_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_player;

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

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

    libHALA_gv_heroAlarakIsPlayerCastingDeadlyCharge[lv_player] = false;
    libHALA_gv_heroAlarakActiveDeadlyChargeCasters -= 1;
    libHALA_gv_heroAlarakActiveDeadlyChargeCasters = libNtve_gf_ArithmeticIntClamp(libHALA_gv_heroAlarakActiveDeadlyChargeCasters, 0, 10);
    if ((libHALA_gv_heroAlarakActiveDeadlyChargeCasters == 0)) {
        TriggerEnable(libHALA_gt_HeroAlarakDeadlyChargeCasterClicked, false);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libHALA_gt_HeroAlarakDeadlyChargeTurnTriggersOff_Init () {
    libHALA_gt_HeroAlarakDeadlyChargeTurnTriggersOff = TriggerCreate("libHALA_gt_HeroAlarakDeadlyChargeTurnTriggersOff_Func");
    TriggerEnable(libHALA_gt_HeroAlarakDeadlyChargeTurnTriggersOff, false);
    TriggerAddEventUnitBehaviorChange(libHALA_gt_HeroAlarakDeadlyChargeTurnTriggersOff, null, "AlarakDeadlyChargeChanneling", c_unitBehaviorChangeDestroy);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Alarak - Deadly Charge - Caster Clicked
//--------------------------------------------------------------------------------------------------
bool libHALA_gt_HeroAlarakDeadlyChargeCasterClicked_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_player;
    unit lv_unit;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_player = EventPlayer();
    lv_unit = libGame_gv_players[lv_player].lv_heroUnit;

    // Conditions
    if (testConds) {
        if (!((libHALA_gv_heroAlarakIsPlayerCastingDeadlyCharge[lv_player] == true))) {
            return false;
        }
    }

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

    if ((UnitHasBehavior2(lv_unit, "AlarakDeadlyChargeAsHeroic") == true)) {
        UnitIssueOrder(lv_unit, Order(AbilityCommand("AlarakDeadlyChargeExecute", 0)), c_orderQueueReplace);
    }
    else {
        UnitIssueOrder(lv_unit, Order(AbilityCommand("AlarakDeadlyChargeExecute2ndHeroic", 0)), c_orderQueueReplace);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHALA_gt_HeroAlarakDeadlyChargeCasterClicked_Init () {
    libHALA_gt_HeroAlarakDeadlyChargeCasterClicked = TriggerCreate("libHALA_gt_HeroAlarakDeadlyChargeCasterClicked_Func");
    TriggerEnable(libHALA_gt_HeroAlarakDeadlyChargeCasterClicked, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Alarak - Deadly Charge - Execute Effect
//--------------------------------------------------------------------------------------------------
bool libHALA_gt_HeroAlarakDeadlyChargeExecuteEffect_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_unit;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_unit = EventPlayerEffectUsedUnit(c_effectUnitCaster);

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

    UnitCreateEffectPoint(lv_unit, "AlarakDeadlyChargeExecuteSet", PointWithOffsetPolar(UnitGetPosition(lv_unit), 1.0, UnitGetFacing(lv_unit)));
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHALA_gt_HeroAlarakDeadlyChargeExecuteEffect_Init () {
    libHALA_gt_HeroAlarakDeadlyChargeExecuteEffect = TriggerCreate("libHALA_gt_HeroAlarakDeadlyChargeExecuteEffect_Func");
    TriggerEnable(libHALA_gt_HeroAlarakDeadlyChargeExecuteEffect, false);
    TriggerAddEventPlayerEffectUsed(libHALA_gt_HeroAlarakDeadlyChargeExecuteEffect, c_playerAny, "AlarakDeadlyChargeExecuteTriggerDummy");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Alarak - Counter-Strike - Set Facing
//--------------------------------------------------------------------------------------------------
bool libHALA_gt_HeroAlarakCounterStrikeSetFacing_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libNtve_gf_MakeUnitFacePoint(EventPlayerEffectUsedUnit(c_effectUnitCaster), UnitGetPosition(EventPlayerEffectUsedUnit(c_effectUnitTarget)), 0.0);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHALA_gt_HeroAlarakCounterStrikeSetFacing_Init () {
    libHALA_gt_HeroAlarakCounterStrikeSetFacing = TriggerCreate("libHALA_gt_HeroAlarakCounterStrikeSetFacing_Func");
    TriggerEnable(libHALA_gt_HeroAlarakCounterStrikeSetFacing, false);
    TriggerAddEventPlayerEffectUsed(libHALA_gt_HeroAlarakCounterStrikeSetFacing, c_playerAny, "AlarakCounterStrikeProcSet");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Alarak - Counter-Strike - Damage Response Proc
//--------------------------------------------------------------------------------------------------
bool libHALA_gt_HeroAlarakCounterStrikeDamageResponseProc_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_caster;
    unit lv_target;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_caster = EventPlayerEffectUsedUnit(c_effectUnitCaster);
    lv_target = EventPlayerEffectUsedUnit(c_effectUnitTarget);

    // Conditions
    if (testConds) {
        if (!((lv_target != null))) {
            return false;
        }

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

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

    if ((UnitBehaviorCount(lv_caster, "AlarakCounterStrikeReady") == 0)) {
        UnitCreateEffectUnit(lv_target, "AlarakCounterStrikeApplyReadyBehavior", lv_caster);
        UnitGroupAdd(libHALA_gv_heroAlarakCounterStrikeUnitGroup[UnitGetOwner(lv_caster)], libGame_gv_players[UnitGetOwner(lv_target)].lv_heroUnit);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libHALA_gt_HeroAlarakCounterStrikeDamageResponseProc_Init () {
    libHALA_gt_HeroAlarakCounterStrikeDamageResponseProc = TriggerCreate("libHALA_gt_HeroAlarakCounterStrikeDamageResponseProc_Func");
    TriggerEnable(libHALA_gt_HeroAlarakCounterStrikeDamageResponseProc, false);
    TriggerAddEventPlayerEffectUsed(libHALA_gt_HeroAlarakCounterStrikeDamageResponseProc, c_playerAny, "AlarakCounterStrikeDamageResponseDummy");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Alarak - Counter-Strike - Unit Group Reset
//--------------------------------------------------------------------------------------------------
bool libHALA_gt_HeroAlarakCounterStrikeUnitGroupReset_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_caster;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_caster = EventPlayerEffectUsedUnit(c_effectUnitCaster);

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

    UnitGroupClear(libHALA_gv_heroAlarakCounterStrikeUnitGroup[UnitGetOwner(lv_caster)]);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHALA_gt_HeroAlarakCounterStrikeUnitGroupReset_Init () {
    libHALA_gt_HeroAlarakCounterStrikeUnitGroupReset = TriggerCreate("libHALA_gt_HeroAlarakCounterStrikeUnitGroupReset_Func");
    TriggerEnable(libHALA_gt_HeroAlarakCounterStrikeUnitGroupReset, false);
    TriggerAddEventPlayerEffectUsed(libHALA_gt_HeroAlarakCounterStrikeUnitGroupReset, c_playerAny, "AlarakCounterStrikeCastSet");
    TriggerAddEventPlayerEffectUsed(libHALA_gt_HeroAlarakCounterStrikeUnitGroupReset, c_playerAny, "AlarakCounterStrikeProcPersistentFinalSet");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Alarak - Counter-Strike Protected On/Off
//--------------------------------------------------------------------------------------------------
bool libHALA_gt_HeroAlarakCounterStrikeProtectedOnOff_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_player;
    int lv_index;

    // Automatic Variable Declarations
    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((UnitGetOwner(EventUnit()) >= 1))) {
            return false;
        }

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

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

        if (!((UnitBehaviorCount(EventUnit(), "HeroGenericHasNoStatusBar") == 0))) {
            return false;
        }
    }

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

    lv_player = UnitGetOwner(EventUnit());
    lv_index = libUIUI_gf_UIUnitStatusFramesGetUnitIndex(lv_player, EventUnit());
    if ((EventUnitBehaviorChange() == c_unitBehaviorChangeActivate)) {
        DialogControlSendAnimationEvent(libUIUI_gv_uIHeroStatusFrames[lv_player].lv_unitHealthBarInvincible[lv_index], PlayerGroupAll(), "InvincibleOn");
        libUIUI_gv_uIHeroBehaviorStates[lv_player].lv_invincibleActive[lv_index] = true;
    }
    else {
        DialogControlSendAnimationEvent(libUIUI_gv_uIHeroStatusFrames[lv_player].lv_unitHealthBarInvincible[lv_index], PlayerGroupAll(), "InvincibleOff");
        libUIUI_gv_uIHeroBehaviorStates[lv_player].lv_invincibleActive[lv_index] = false;
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHALA_gt_HeroAlarakCounterStrikeProtectedOnOff_Init () {
    libHALA_gt_HeroAlarakCounterStrikeProtectedOnOff = TriggerCreate("libHALA_gt_HeroAlarakCounterStrikeProtectedOnOff_Func");
    TriggerEnable(libHALA_gt_HeroAlarakCounterStrikeProtectedOnOff, false);
    TriggerAddEventUnitBehaviorChange(libHALA_gt_HeroAlarakCounterStrikeProtectedOnOff, null, "AlarakCounterStrikeShield", c_unitBehaviorChangeActivate);
    TriggerAddEventUnitBehaviorChange(libHALA_gt_HeroAlarakCounterStrikeProtectedOnOff, null, "AlarakCounterStrikeShield", c_unitBehaviorChangeDeactivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Alarak - Pure Malice - Ally Death Proc
//--------------------------------------------------------------------------------------------------
bool libHALA_gt_HeroAlarakPureMaliceAllyDeathProc_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_player;
    unit lv_pickedUnit;
    int lv_deadUnitOwner;
    point lv_deadUnitLocation;

    // Automatic Variable Declarations
    playergroup autoF00BC071_g;
    int autoF00BC071_var;

    // Variable Initialization

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

    if ((EventGenericName() == "HeroKilled")) {
        lv_deadUnitOwner = libGame_gf_HeroKilledPlayer();
        lv_deadUnitLocation = libGame_gf_HeroKilledLocation();
    }
    else {
        lv_deadUnitOwner = libGame_gf_HeroAllyKilledPlayer();
        lv_deadUnitLocation = libGame_gf_HeroAllyKilledLocation();
    }
    autoF00BC071_g = PlayerGroupAlliance(c_playerGroupAlly, lv_deadUnitOwner);
    autoF00BC071_var = -1;
    while (true) {
        	autoF00BC071_var = PlayerGroupNextPlayer(autoF00BC071_g, autoF00BC071_var);
        	if (autoF00BC071_var<0) { break; }
        	lv_player = autoF00BC071_var;
        if ((lv_player != lv_deadUnitOwner) && (UnitIsAlive(libGame_gv_players[lv_player].lv_heroUnit) == true) && (lv_player <= libCore_gv_bALMaxPlayers) && (UnitGetType(libGame_gv_players[lv_player].lv_heroUnit) == "HeroAlarak") && (PlayerHasTalent(lv_player, "AlarakPureMalice") == true)) {
            lv_pickedUnit = libGame_gv_players[lv_player].lv_heroUnit;
            if ((UnitBehaviorCount(lv_pickedUnit, "AlarakSadismPureMaliceTalentStack") < 4)) {
                UnitCreateEffectUnit(lv_pickedUnit, "AlarakSadismApplyPureMaliceTalentStack", lv_pickedUnit);
            }

        }

    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHALA_gt_HeroAlarakPureMaliceAllyDeathProc_Init () {
    libHALA_gt_HeroAlarakPureMaliceAllyDeathProc = TriggerCreate("libHALA_gt_HeroAlarakPureMaliceAllyDeathProc_Func");
    TriggerEnable(libHALA_gt_HeroAlarakPureMaliceAllyDeathProc, false);
    libGame_gf_HeroKilled(libHALA_gt_HeroAlarakPureMaliceAllyDeathProc);
    libGame_gf_HeroAllyKilled(libHALA_gt_HeroAlarakPureMaliceAllyDeathProc);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Alarak - Rite of Rak'Shir FX Debuff And Caster Reveal
//--------------------------------------------------------------------------------------------------
bool libHALA_gt_HeroAlarakRiteofRakShirFXDebuffAndCasterReveal_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_unit;

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

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

    UnitCreateEffectUnit(lv_unit, "AlarakSadismRiteofRakShirMarkerDummy", lv_unit);
    if ((libHALA_gv_heroAlarakRiteofRakShirActivelyTransferring[UnitBehaviorEffectPlayer(lv_unit, "AlarakSadismRiteofRakShirTalentDebuff", c_effectPlayerCaster, 0)] == false)) {
        UnitCreateEffectUnit(UnitBehaviorEffectUnit(EventUnit(), EventUnitBehavior(), c_effectUnitCaster, 0), "OneOffDamageRevealSourceApplyRevealer", lv_unit);
    }
    else {
        libHALA_gv_heroAlarakRiteofRakShirActivelyTransferring[UnitBehaviorEffectPlayer(lv_unit, "AlarakSadismRiteofRakShirTalentDebuff", c_effectPlayerCaster, 0)] = false;
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHALA_gt_HeroAlarakRiteofRakShirFXDebuffAndCasterReveal_Init () {
    libHALA_gt_HeroAlarakRiteofRakShirFXDebuffAndCasterReveal = TriggerCreate("libHALA_gt_HeroAlarakRiteofRakShirFXDebuffAndCasterReveal_Func");
    TriggerEnable(libHALA_gt_HeroAlarakRiteofRakShirFXDebuffAndCasterReveal, false);
    TriggerAddEventUnitBehaviorChange(libHALA_gt_HeroAlarakRiteofRakShirFXDebuffAndCasterReveal, null, "AlarakSadismRiteofRakShirTalentDebuff", c_unitBehaviorChangeActivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Alarak - Rite of Rak'Shir Transport Redirect
//--------------------------------------------------------------------------------------------------
bool libHALA_gt_HeroAlarakRiteofRakShirTransportRedirect_Func (bool testConds, bool runActions) {
    // Variable Declarations
    string lv_effect;
    fixed lv_behaviorDuration;
    unit lv_transportingUnit;
    unit lv_transportedUnit;
    unit lv_oldTarget;
    unit lv_newTarget;
    unit lv_alarak;

    // Automatic Variable Declarations
    fixed auto86D088E3_at;

    // Variable Initialization
    lv_effect = EventPlayerEffectUsed();
    lv_transportingUnit = EventPlayerEffectUsedUnit(c_effectUnitCaster);
    lv_transportedUnit = EventPlayerEffectUsedUnit(c_effectUnitTarget);

    // Conditions
    if (testConds) {
        if (!((UnitGetOwner(lv_transportedUnit) >= 1))) {
            return false;
        }

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

        if (!(((UnitBehaviorCount(lv_transportingUnit, "AlarakSadismRiteofRakShirTalentDebuff") == 1) || (UnitBehaviorCount(lv_transportedUnit, "AlarakSadismRiteofRakShirTalentDebuff") == 1)))) {
            return false;
        }
    }

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

    if ((lv_effect == "HeroGenericLoadTransportRedirectBehaviorsDummy")) {
        lv_oldTarget = lv_transportedUnit;
        lv_newTarget = lv_transportingUnit;
    }
    else {
        lv_oldTarget = lv_transportingUnit;
        lv_newTarget = lv_transportedUnit;
    }
    lv_alarak = UnitBehaviorEffectUnit(lv_oldTarget, "AlarakSadismRiteofRakShirTalentDebuff", c_effectUnitSource, 0);
    lv_behaviorDuration = UnitBehaviorDuration(lv_oldTarget, "AlarakSadismRiteofRakShirTalentDebuff");
    libHALA_gv_heroAlarakRiteofRakShirActivelyTransferring[UnitGetOwner(lv_alarak)] = true;
    UnitBehaviorAdd(lv_newTarget, "AlarakSadismRiteofRakShirSuppressVOX", lv_alarak, 1);
    UnitCreateEffectUnit(lv_alarak, "AlarakSadismRiteofRakShirTalentApplyDebuff", lv_newTarget);
    UnitBehaviorRemove(lv_oldTarget, "AlarakSadismRiteofRakShirTalentDebuff", 1);
    auto86D088E3_at = 0;
    while (!((UnitBehaviorCount(lv_newTarget, "AlarakSadismRiteofRakShirTalentDebuff") == 1)) && auto86D088E3_at <= 5.0) {
        Wait(0.0625, c_timeGame);
        auto86D088E3_at = auto86D088E3_at + 0.0625;
    }
    UnitBehaviorSetDurationRemaining(lv_newTarget, "AlarakSadismRiteofRakShirTalentDebuff", lv_behaviorDuration);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHALA_gt_HeroAlarakRiteofRakShirTransportRedirect_Init () {
    libHALA_gt_HeroAlarakRiteofRakShirTransportRedirect = TriggerCreate("libHALA_gt_HeroAlarakRiteofRakShirTransportRedirect_Func");
    TriggerEnable(libHALA_gt_HeroAlarakRiteofRakShirTransportRedirect, false);
    TriggerAddEventPlayerEffectUsed(libHALA_gt_HeroAlarakRiteofRakShirTransportRedirect, c_playerAny, "HeroGenericLoadTransportRedirectBehaviorsDummy");
    TriggerAddEventPlayerEffectUsed(libHALA_gt_HeroAlarakRiteofRakShirTransportRedirect, c_playerAny, "HeroGenericUnloadTransportRedirectBehaviorsDummy");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Alarak - Rite of Rak'Shir Target Dies
//--------------------------------------------------------------------------------------------------
bool libHALA_gt_HeroAlarakRiteofRakShirTargetDies_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_iter;
    unit lv_deadUnit;
    unit lv_alarakUnit;

    // Automatic Variable Declarations
    int autoB6FE2083_ae;
    const int autoB6FE2083_ai = 1;

    // Variable Initialization
    lv_deadUnit = EventUnit();

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

        if (!((UnitTestState(lv_deadUnit, c_unitStateIsTransport) == false))) {
            return false;
        }
    }

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

    if ((UnitGetType(lv_deadUnit) == "LongboatRaidBoat") && (UnitHasBehavior2(lv_deadUnit, "LostVikingsLongboatRaidDeathDummy") == false)) {
        return true;
    }

    autoB6FE2083_ae = (UnitBehaviorCount(lv_deadUnit, "AlarakSadismRiteofRakShirTalentDebuff") - 1);
    lv_iter = 0;
    for ( ; ( (autoB6FE2083_ai >= 0 && lv_iter <= autoB6FE2083_ae) || (autoB6FE2083_ai < 0 && lv_iter >= autoB6FE2083_ae) ) ; lv_iter += autoB6FE2083_ai ) {
        lv_alarakUnit = UnitBehaviorEffectUnit(lv_deadUnit, "AlarakSadismRiteofRakShirTalentDebuff", c_effectUnitCaster, lv_iter);
        UnitCreateEffectUnit(lv_alarakUnit, "AlarakSadismRiteofRakShirTalentResetPlayerCooldown", lv_alarakUnit);
        if ((UnitTestState(lv_deadUnit, c_unitStateHallucination) == false) && (UnitHasBehavior2(lv_deadUnit, "IsPseudoStructure") == false)) {
            UnitCreateEffectUnit(lv_alarakUnit, "AlarakSadismRiteofRakShirTalentApplyKillStack", lv_alarakUnit);
        }

    }
    UnitBehaviorRemove(lv_deadUnit, "AlarakSadismRiteofRakShirTalentDebuff", -1);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHALA_gt_HeroAlarakRiteofRakShirTargetDies_Init () {
    libHALA_gt_HeroAlarakRiteofRakShirTargetDies = TriggerCreate("libHALA_gt_HeroAlarakRiteofRakShirTargetDies_Func");
    TriggerEnable(libHALA_gt_HeroAlarakRiteofRakShirTargetDies, false);
    TriggerAddEventUnitDied(libHALA_gt_HeroAlarakRiteofRakShirTargetDies, null);
    TriggerAddEventUnitBehaviorChangeFromCategory(libHALA_gt_HeroAlarakRiteofRakShirTargetDies, null, c_behaviorCategorySpecialDeathState, c_unitBehaviorChangeCreate);
    TriggerAddEventUnitBehaviorChange(libHALA_gt_HeroAlarakRiteofRakShirTargetDies, null, "LostVikingsLongboatRaidDeathDummy", c_unitBehaviorChangeCreate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Alarak - Sadism - Takedown Bonus Proc
//--------------------------------------------------------------------------------------------------
bool libHALA_gt_HeroAlarakSadismTakedownBonusProc_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_player;

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

    // Conditions
    if (testConds) {
        if (!((lv_player >= 1))) {
            return false;
        }

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

        if (!((UnitIsAlive(libGame_gv_players[lv_player].lv_heroUnit) == true))) {
            return false;
        }
    }

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

    UnitCreateEffectUnit(libGame_gv_players[lv_player].lv_heroUnit, "AlarakSadismModifyTakedownTokenCounter", libGame_gv_players[lv_player].lv_heroUnit);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHALA_gt_HeroAlarakSadismTakedownBonusProc_Init () {
    libHALA_gt_HeroAlarakSadismTakedownBonusProc = TriggerCreate("libHALA_gt_HeroAlarakSadismTakedownBonusProc_Func");
    TriggerEnable(libHALA_gt_HeroAlarakSadismTakedownBonusProc, false);
    libGame_gf_HeroParticipatedInTakedown(libHALA_gt_HeroAlarakSadismTakedownBonusProc);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Alarak - Sadism Respec Reset
//--------------------------------------------------------------------------------------------------
bool libHALA_gt_HeroAlarakSadismRespecReset_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_player;

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

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

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

    UnitSetTokenCount(libGame_gv_players[lv_player].lv_heroUnit, CatalogFieldValueGet(c_gameCatalogBehavior, "AlarakSadismToken", "TokenId", c_playerAny), StringToFixed(CatalogFieldValueGet(c_gameCatalogBehavior, "AlarakSadismToken", "Init", c_playerAny)), libGame_gv_players[lv_player].lv_heroUnit);
    UnitSetTokenCount(libGame_gv_players[lv_player].lv_heroUnit, CatalogFieldValueGet(c_gameCatalogBehavior, "AlarakSadismDeathReductionTokenCounter", "TokenId", c_playerAny), StringToFixed(CatalogFieldValueGet(c_gameCatalogBehavior, "AlarakSadismDeathReductionTokenCounter", "Init", c_playerAny)), libGame_gv_players[lv_player].lv_heroUnit);
    UnitSetTokenCount(libGame_gv_players[lv_player].lv_heroUnit, CatalogFieldValueGet(c_gameCatalogBehavior, "AlarakSadismTakedownIncreaseTokenCounter", "TokenId", c_playerAny), StringToFixed(CatalogFieldValueGet(c_gameCatalogBehavior, "AlarakSadismTakedownIncreaseTokenCounter", "Init", c_playerAny)), libGame_gv_players[lv_player].lv_heroUnit);
    libHALA_gf_HeroAlarakUpdateSadismUI(lv_player);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHALA_gt_HeroAlarakSadismRespecReset_Init () {
    libHALA_gt_HeroAlarakSadismRespecReset = TriggerCreate("libHALA_gt_HeroAlarakSadismRespecReset_Func");
    TriggerEnable(libHALA_gt_HeroAlarakSadismRespecReset, false);
    libGame_gf_HeroRespecsTalents(libHALA_gt_HeroAlarakSadismRespecReset);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Alarak - Sadism Tokens Modified
//--------------------------------------------------------------------------------------------------
bool libHALA_gt_HeroAlarakSadismTokensModified_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_player;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_player = EventPlayerEffectUsedUnitOwner(c_effectPlayerTarget);

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

    libHALA_gf_HeroAlarakUpdateSadismUI(lv_player);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHALA_gt_HeroAlarakSadismTokensModified_Init () {
    libHALA_gt_HeroAlarakSadismTokensModified = TriggerCreate("libHALA_gt_HeroAlarakSadismTokensModified_Func");
    TriggerEnable(libHALA_gt_HeroAlarakSadismTokensModified, false);
    TriggerAddEventPlayerEffectUsed(libHALA_gt_HeroAlarakSadismTokensModified, c_playerAny, "AlarakSadismTokenModifiedDummy");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Alarak - Surge Actor Messages
//--------------------------------------------------------------------------------------------------
bool libHALA_gt_HeroAlarakSurgeActorMessages_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_unit;
    int lv_player;
    string lv_effectString;
    string lv_searchNumber;
    fixed lv_finalNumberReal;
    string lv_finalNumberString;
    text lv_finalNumberText;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_unit = EventPlayerEffectUsedUnit(c_effectUnitCaster);
    lv_player = EventPlayerEffectUsedUnitOwner(c_effectPlayerCaster);
    lv_effectString = (EventPlayerEffectUsed());
    lv_searchNumber = StringReplaceWord(lv_effectString, "AlarakLightningSurgeSearch", "", c_stringReplaceAll, c_stringCase);
    lv_finalNumberReal = (StringToFixed(lv_searchNumber) * 0.12);
    lv_finalNumberString = FixedToString(lv_finalNumberReal, 3);
    lv_finalNumberText = StringToText(lv_finalNumberString);

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

    lv_finalNumberReal = (StringToFixed(lv_searchNumber) * 0.12);
    if ((lv_finalNumberReal > 14.0)) {
        lv_finalNumberReal = 14.0;
    }

    if ((lv_searchNumber == "1")) {
        lv_finalNumberReal = 0.2;
        ActorSendTo(libNtve_gf_MainActorofUnit(lv_unit), "AlarakLightningSurgeReticule", "AnimSetTime Custom 0.200000");
        ActorSendTo(libNtve_gf_MainActorofUnit(lv_unit), "AlarakLightningSurgeBeam", "AnimSetTime Custom 0.200000");
    }
    else if ((lv_searchNumber == "2")) {
        lv_finalNumberReal = 0.3;
        ActorSendTo(libNtve_gf_MainActorofUnit(lv_unit), "AlarakLightningSurgeReticule", "AnimSetTime Custom 0.300000");
        ActorSendTo(libNtve_gf_MainActorofUnit(lv_unit), "AlarakLightningSurgeBeam", "AnimSetTime Custom 0.300000");
    }
    else if ((lv_searchNumber == "3")) {
        lv_finalNumberReal = 0.39;
        ActorSendTo(libNtve_gf_MainActorofUnit(lv_unit), "AlarakLightningSurgeReticule", "AnimSetTime Custom 0.390000");
        ActorSendTo(libNtve_gf_MainActorofUnit(lv_unit), "AlarakLightningSurgeBeam", "AnimSetTime Custom 0.390000");
    }
    else if ((lv_searchNumber == "4")) {
        lv_finalNumberReal = 0.43;
        ActorSendTo(libNtve_gf_MainActorofUnit(lv_unit), "AlarakLightningSurgeReticule", "AnimSetTime Custom 0.430000");
        ActorSendTo(libNtve_gf_MainActorofUnit(lv_unit), "AlarakLightningSurgeBeam", "AnimSetTime Custom 0.430000");
    }
    else if ((lv_searchNumber == "5")) {
        lv_finalNumberReal = 0.54;
        ActorSendTo(libNtve_gf_MainActorofUnit(lv_unit), "AlarakLightningSurgeReticule", "AnimSetTime Custom 0.540000");
        ActorSendTo(libNtve_gf_MainActorofUnit(lv_unit), "AlarakLightningSurgeBeam", "AnimSetTime Custom 0.540000");
    }
    else if ((lv_searchNumber == "6")) {
        lv_finalNumberReal = 0.6;
        ActorSendTo(libNtve_gf_MainActorofUnit(lv_unit), "AlarakLightningSurgeReticule", "AnimSetTime Custom 0.600000");
        ActorSendTo(libNtve_gf_MainActorofUnit(lv_unit), "AlarakLightningSurgeBeam", "AnimSetTime Custom 0.600000");
    }
    else if ((lv_searchNumber == "7")) {
        lv_finalNumberReal = 0.68;
        ActorSendTo(libNtve_gf_MainActorofUnit(lv_unit), "AlarakLightningSurgeReticule", "AnimSetTime Custom 0.680000");
        ActorSendTo(libNtve_gf_MainActorofUnit(lv_unit), "AlarakLightningSurgeBeam", "AnimSetTime Custom 0.680000");
    }
    else if ((lv_searchNumber == "8")) {
        lv_finalNumberReal = 0.74;
        ActorSendTo(libNtve_gf_MainActorofUnit(lv_unit), "AlarakLightningSurgeReticule", "AnimSetTime Custom 0.740000");
        ActorSendTo(libNtve_gf_MainActorofUnit(lv_unit), "AlarakLightningSurgeBeam", "AnimSetTime Custom 0.740000");
    }
    else if ((lv_searchNumber == "9")) {
        lv_finalNumberReal = 0.81;
        ActorSendTo(libNtve_gf_MainActorofUnit(lv_unit), "AlarakLightningSurgeReticule", "AnimSetTime Custom 0.810000");
        ActorSendTo(libNtve_gf_MainActorofUnit(lv_unit), "AlarakLightningSurgeBeam", "AnimSetTime Custom 0.810000");
    }
    else if ((lv_searchNumber == "10")) {
        lv_finalNumberReal = 0.88;
        ActorSendTo(libNtve_gf_MainActorofUnit(lv_unit), "AlarakLightningSurgeReticule", "AnimSetTime Custom 0.880000");
        ActorSendTo(libNtve_gf_MainActorofUnit(lv_unit), "AlarakLightningSurgeBeam", "AnimSetTime Custom 0.880000");
    }
    else if ((lv_searchNumber == "11")) {
        lv_finalNumberReal = 0.96;
        ActorSendTo(libNtve_gf_MainActorofUnit(lv_unit), "AlarakLightningSurgeReticule", "AnimSetTime Custom 0.960000");
        ActorSendTo(libNtve_gf_MainActorofUnit(lv_unit), "AlarakLightningSurgeBeam", "AnimSetTime Custom 0.960000");
    }
    else if (((lv_searchNumber == "12") || (lv_searchNumber == "13") || (lv_searchNumber == "14") || (lv_searchNumber == "15") || (lv_searchNumber == "16"))) {
        lv_finalNumberReal = 1.0;
        ActorSendTo(libNtve_gf_MainActorofUnit(lv_unit), "AlarakLightningSurgeReticule", "AnimSetTime Custom 1.000000");
        ActorSendTo(libNtve_gf_MainActorofUnit(lv_unit), "AlarakLightningSurgeBeam", "AnimSetTime Custom 1.000000");
    }
    lv_finalNumberString = FixedToString(lv_finalNumberReal, 3);
    lv_finalNumberText = StringToText(lv_finalNumberString);
    ActorSendTo(libNtve_gf_MainActorofUnit(lv_unit), "AlarakLightningSurgeReticule", "AnimSetPaused Custom");
    ActorSendTo(libNtve_gf_MainActorofUnit(lv_unit), "AlarakLightningSurgeBeam", "AnimSetPaused Custom");
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHALA_gt_HeroAlarakSurgeActorMessages_Init () {
    libHALA_gt_HeroAlarakSurgeActorMessages = TriggerCreate("libHALA_gt_HeroAlarakSurgeActorMessages_Func");
    TriggerEnable(libHALA_gt_HeroAlarakSurgeActorMessages, false);
    TriggerAddEventPlayerEffectUsed(libHALA_gt_HeroAlarakSurgeActorMessages, c_playerAny, "AlarakLightningSurgeSearch1");
    TriggerAddEventPlayerEffectUsed(libHALA_gt_HeroAlarakSurgeActorMessages, c_playerAny, "AlarakLightningSurgeSearch2");
    TriggerAddEventPlayerEffectUsed(libHALA_gt_HeroAlarakSurgeActorMessages, c_playerAny, "AlarakLightningSurgeSearch3");
    TriggerAddEventPlayerEffectUsed(libHALA_gt_HeroAlarakSurgeActorMessages, c_playerAny, "AlarakLightningSurgeSearch4");
    TriggerAddEventPlayerEffectUsed(libHALA_gt_HeroAlarakSurgeActorMessages, c_playerAny, "AlarakLightningSurgeSearch5");
    TriggerAddEventPlayerEffectUsed(libHALA_gt_HeroAlarakSurgeActorMessages, c_playerAny, "AlarakLightningSurgeSearch6");
    TriggerAddEventPlayerEffectUsed(libHALA_gt_HeroAlarakSurgeActorMessages, c_playerAny, "AlarakLightningSurgeSearch7");
    TriggerAddEventPlayerEffectUsed(libHALA_gt_HeroAlarakSurgeActorMessages, c_playerAny, "AlarakLightningSurgeSearch8");
    TriggerAddEventPlayerEffectUsed(libHALA_gt_HeroAlarakSurgeActorMessages, c_playerAny, "AlarakLightningSurgeSearch9");
    TriggerAddEventPlayerEffectUsed(libHALA_gt_HeroAlarakSurgeActorMessages, c_playerAny, "AlarakLightningSurgeSearch10");
    TriggerAddEventPlayerEffectUsed(libHALA_gt_HeroAlarakSurgeActorMessages, c_playerAny, "AlarakLightningSurgeSearch11");
    TriggerAddEventPlayerEffectUsed(libHALA_gt_HeroAlarakSurgeActorMessages, c_playerAny, "AlarakLightningSurgeSearch12");
    TriggerAddEventPlayerEffectUsed(libHALA_gt_HeroAlarakSurgeActorMessages, c_playerAny, "AlarakLightningSurgeSearch13");
    TriggerAddEventPlayerEffectUsed(libHALA_gt_HeroAlarakSurgeActorMessages, c_playerAny, "AlarakLightningSurgeSearch14");
    TriggerAddEventPlayerEffectUsed(libHALA_gt_HeroAlarakSurgeActorMessages, c_playerAny, "AlarakLightningSurgeSearch15");
    TriggerAddEventPlayerEffectUsed(libHALA_gt_HeroAlarakSurgeActorMessages, c_playerAny, "AlarakLightningSurgeSearch16");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Alarak - UI Initialize
//--------------------------------------------------------------------------------------------------
bool libHALA_gt_HeroAlarakUIInitialize_Func (bool testConds, bool runActions) {
    int init_i;

    // Variable Declarations
    int[6] lv_panels;
    int lv_currentPanelLayer;

    // Automatic Variable Declarations
    // Variable Initialization
    for (init_i = 0; init_i <= 5; init_i += 1) {
        lv_panels[init_i] = c_invalidDialogControlId;
    }

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

    DialogControlHookup(libUIUI_gv_heroSpecificStatusContainer, c_triggerControlTypePanel, "AlarakFrame");
    libHALA_gv_alarakUI.lv_mainPanel = DialogControlLastCreated();
    lv_currentPanelLayer += 1;
    lv_panels[lv_currentPanelLayer] = DialogControlLastCreated();
    DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypeProgressBar, "UnitStatusFrame0/AlarakSadismProgressBar");
    libHALA_gv_alarakUI.lv_sadismProgressBar = DialogControlLastCreated();
    DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypeLabel, "UnitStatusFrame0/SadismLabel");
    libHALA_gv_alarakUI.lv_sadismPercentageLabel = DialogControlLastCreated();
    DialogControlHookup(lv_panels[lv_currentPanelLayer], c_triggerControlTypeImage, "UnitStatusFrame0/ExtraGlowImage");
    libHALA_gv_alarakUI.lv_sadismExtraGlowImage = DialogControlLastCreated();
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHALA_gt_HeroAlarakUIInitialize_Init () {
    libHALA_gt_HeroAlarakUIInitialize = TriggerCreate("libHALA_gt_HeroAlarakUIInitialize_Func");
    libCore_gf_IncludeModInitialization(libHALA_gt_HeroAlarakUIInitialize);
}

void libHALA_InitTriggers () {
    libHALA_gt_HeroAlarakHeroSpawned_Init();
    libHALA_gt_HeroAlarakDeadlyChargeTurnTriggersOn_Init();
    libHALA_gt_HeroAlarakDeadlyChargeTurnTriggersOff_Init();
    libHALA_gt_HeroAlarakDeadlyChargeCasterClicked_Init();
    libHALA_gt_HeroAlarakDeadlyChargeExecuteEffect_Init();
    libHALA_gt_HeroAlarakCounterStrikeSetFacing_Init();
    libHALA_gt_HeroAlarakCounterStrikeDamageResponseProc_Init();
    libHALA_gt_HeroAlarakCounterStrikeUnitGroupReset_Init();
    libHALA_gt_HeroAlarakCounterStrikeProtectedOnOff_Init();
    libHALA_gt_HeroAlarakPureMaliceAllyDeathProc_Init();
    libHALA_gt_HeroAlarakRiteofRakShirFXDebuffAndCasterReveal_Init();
    libHALA_gt_HeroAlarakRiteofRakShirTransportRedirect_Init();
    libHALA_gt_HeroAlarakRiteofRakShirTargetDies_Init();
    libHALA_gt_HeroAlarakSadismTakedownBonusProc_Init();
    libHALA_gt_HeroAlarakSadismRespecReset_Init();
    libHALA_gt_HeroAlarakSadismTokensModified_Init();
    libHALA_gt_HeroAlarakSurgeActorMessages_Init();
    libHALA_gt_HeroAlarakUIInitialize_Init();
}

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

void libHALA_InitLib () {
    if (libHALA_InitLib_completed) {
        return;
    }

    libHALA_InitLib_completed = true;

    libHALA_InitLibraries();
    libHALA_InitVariables();
    libHALA_InitTriggers();
}