LibHZUL.galaxy

include "TriggerLibs/NativeLib"
include "TriggerLibs/HeroesLib"
include "TriggerLibs/GameLib"
include "TriggerLibs/UILib"
include "TriggerLibs/SoundLib"

include "LibHZUL_h"

//--------------------------------------------------------------------------------------------------
// Library: Zul'jin
//--------------------------------------------------------------------------------------------------
// External Library Initialization
void libHZUL_InitLibraries () {
    libNtve_InitVariables();
    libCore_InitVariables();
    libGame_InitVariables();
    libUIUI_InitVariables();
    libSond_InitVariables();
}

// Variable Initialization
bool libHZUL_InitVariables_completed = false;

void libHZUL_InitVariables () {
    int init_i;

    if (libHZUL_InitVariables_completed) {
        return;
    }

    libHZUL_InitVariables_completed = true;

    libHZUL_gv_zuljinUI.lv_mainPanel = c_invalidDialogControlId;
    libHZUL_gv_zuljinUI.lv_traitPanel = c_invalidDialogControlId;
    libHZUL_gv_zuljinUI.lv_berserkerValueLabel = c_invalidDialogControlId;
    libHZUL_gv_zuljinUI.lv_guillotineDamageLabel = c_invalidDialogControlId;
    for (init_i = 0; init_i <= libCore_gv_bALMaxPlayers; init_i += 1) {
        libHZUL_gv_heroZuljinHeadhunterUnitGroupVictims[init_i] = UnitGroupEmpty();
    }
    for (init_i = 0; init_i <= libCore_gv_bALMaxPlayers; init_i += 1) {
        libHZUL_gv_heroZuljinHeadhunterUnitGroupHitList[init_i] = UnitGroupEmpty();
    }
}

// Functions
void libHZUL_gf_HeroZuljinIncrementHeroCountFunction () {
    // Automatic Variable Declarations
    // Implementation
    libHZUL_gv_heroZuljinTriggerRegistrationVariable += 1;
    if ((libHZUL_gv_heroZuljinTriggerRegistrationVariable == 1)) {
        TriggerEnable(libHZUL_gt_HeroZuljinPlayerSetup, true);
        TriggerEnable(libHZUL_gt_HeroZuljinUICleanUpGuillotine, true);
        TriggerEnable(libHZUL_gt_HeroZuljinBerserkerSetLifeTo1, true);
        TriggerEnable(libHZUL_gt_HeroZuljinGuillotineCastModifyDamage, true);
        TriggerEnable(libHZUL_gt_HeroZuljinGuillotineTalentSelected, true);
        TriggerEnable(libHZUL_gt_HeroZuljinGuillotineVODeadKill, true);
        TriggerEnable(libHZUL_gt_HeroZuljinAmaniRageCast, true);
        TriggerEnable(libHZUL_gt_HeroZuljinHeadhunterSelected, true);
        TriggerEnable(libHZUL_gt_HeroZuljinHeadhunterProgress, true);
        TriggerEnable(libHZUL_gt_HeroZuljinHeadhunterRespec, true);
        TriggerEnable(libHZUL_gt_HeroZuljinLetTheKillingBeginRefreshDuration, true);
        TriggerEnable(libHZUL_gt_HeroZuljinLetTheKillingBeginHeroTakedown, true);
        TriggerEnable(libHZUL_gt_HeroZuljinFerocityUpdateAccumulator, true);
        TriggerEnable(libHZUL_gt_HeroZuljinFerocityRespec, true);
        TriggerEnable(libHZUL_gt_HeroZuljinAmaniResilienceOn, true);
        TriggerEnable(libHZUL_gt_HeroZuljinAmaniResilienceHealPreviewCatalog, true);
        TriggerEnable(libHZUL_gt_HeroZuljinAmaniResilienceOff, true);
        TriggerEnable(libHZUL_gt_HeroZuljinYouWantAxeScoreValue, true);
        TriggerEnable(libHZUL_gt_HeroZuljinYouWantAxeScoreValueReset, true);
    }

}

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

    if ((libHZUL_gv_heroZuljinTriggerRegistrationVariable == 0)) {
        TriggerEnable(libHZUL_gt_HeroZuljinPlayerSetup, false);
        TriggerEnable(libHZUL_gt_HeroZuljinUICleanUpGuillotine, false);
        TriggerEnable(libHZUL_gt_HeroZuljinBerserkerSetLifeTo1, false);
        TriggerEnable(libHZUL_gt_HeroZuljinGuillotineCastModifyDamage, false);
        TriggerEnable(libHZUL_gt_HeroZuljinGuillotineTalentSelected, false);
        TriggerEnable(libHZUL_gt_HeroZuljinGuillotineVODeadKill, false);
        TriggerEnable(libHZUL_gt_HeroZuljinAmaniRageCast, false);
        TriggerEnable(libHZUL_gt_HeroZuljinHeadhunterSelected, false);
        TriggerEnable(libHZUL_gt_HeroZuljinHeadhunterProgress, false);
        TriggerEnable(libHZUL_gt_HeroZuljinHeadhunterRespec, false);
        TriggerEnable(libHZUL_gt_HeroZuljinLetTheKillingBeginRefreshDuration, false);
        TriggerEnable(libHZUL_gt_HeroZuljinLetTheKillingBeginHeroTakedown, false);
        TriggerEnable(libHZUL_gt_HeroZuljinFerocityUpdateAccumulator, false);
        TriggerEnable(libHZUL_gt_HeroZuljinFerocityRespec, false);
        TriggerEnable(libHZUL_gt_HeroZuljinAmaniResilienceOn, false);
        TriggerEnable(libHZUL_gt_HeroZuljinAmaniResilienceHealPreviewCatalog, false);
        TriggerEnable(libHZUL_gt_HeroZuljinAmaniResilienceOff, false);
        TriggerEnable(libHZUL_gt_HeroZuljinYouWantAxeScoreValue, false);
        TriggerEnable(libHZUL_gt_HeroZuljinYouWantAxeScoreValueReset, false);
    }

}

void libHZUL_gf_HeroZuljinUpdateGuillotineStatusFrame (int lp_player, fixed lp_damage, fixed lp_healthPercentage) {
    // Variable Declarations
    text lv_textStyle;
    text lv_text;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_textStyle = StringExternal("Param/Value/lib_HZUL_F6EBF598");
    lv_text = FixedToText(lp_damage, 0);

    // Implementation
    libNtve_gf_SetDialogItemText(libHZUL_gv_zuljinUI.lv_guillotineDamageLabel, (lv_textStyle + lv_text + StringExternal("Param/Value/lib_HZUL_57570935")), libCore_gv_playerGroupFromPlayer[lp_player]);
}

trigger auto_libHZUL_gf_ZuljinGuillotineDamageMonitor_Trigger = null;
int auto_libHZUL_gf_ZuljinGuillotineDamageMonitor_lp_player;

void libHZUL_gf_ZuljinGuillotineDamageMonitor (int lp_player) {
    auto_libHZUL_gf_ZuljinGuillotineDamageMonitor_lp_player = lp_player;

    if (auto_libHZUL_gf_ZuljinGuillotineDamageMonitor_Trigger == null) {
        auto_libHZUL_gf_ZuljinGuillotineDamageMonitor_Trigger = TriggerCreate("auto_libHZUL_gf_ZuljinGuillotineDamageMonitor_TriggerFunc");
    }

    TriggerExecute(auto_libHZUL_gf_ZuljinGuillotineDamageMonitor_Trigger, false, false);
}

bool auto_libHZUL_gf_ZuljinGuillotineDamageMonitor_TriggerFunc (bool testConds, bool runActions) {
    int lp_player = auto_libHZUL_gf_ZuljinGuillotineDamageMonitor_lp_player;

    // Variable Declarations
    fixed lv_zuljinLife;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    while (true) {
        lv_zuljinLife = UnitGetPropertyFixed(libGame_gv_players[lp_player].lv_heroUnit, c_unitPropLifePercent, c_unitPropCurrent);
        libHZUL_gv_heroZuljinGuillotineTotalDamage[lp_player] = libHZUL_gf_HeroZuljinGuillotineCalculateDamageBonus(lp_player, lv_zuljinLife, CatalogFieldValueGetAsFixed(c_gameCatalogEffect, "ZuljinGuillotineBaseDamage", "Amount", lp_player));
        libHZUL_gf_HeroZuljinUpdateGuillotineStatusFrame(lp_player, libHZUL_gv_heroZuljinGuillotineTotalDamage[lp_player], lv_zuljinLife);
        Wait(0.25, c_timeGame);
    }
    return true;
}

fixed libHZUL_gf_HeroZuljinGuillotineCalculateDamageBonus (int lp_player, fixed lp_life, fixed lp_guillotineBaseDamage) {
    // Variable Declarations
    fixed lv_maxDamageMultiplier;
    fixed lv_minDamageMultiplier;
    fixed lv_maxLifePercentage;
    fixed lv_minLifePercentage;
    fixed lv_leadingCoefficient;
    fixed lv_quadraticEquation;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_maxDamageMultiplier = 3.0;
    lv_minDamageMultiplier = 1.0;
    lv_maxLifePercentage = 100.0;

    // Implementation
    if ((lp_life < lv_maxLifePercentage)) {
        lv_leadingCoefficient = (lv_maxDamageMultiplier - lv_minDamageMultiplier);
        lv_quadraticEquation = (((lv_leadingCoefficient * Pow((lp_life - lv_maxLifePercentage), 2.0)) / Pow((lv_minLifePercentage - lv_maxLifePercentage), 2.0)) + lv_minDamageMultiplier);
        return (lp_guillotineBaseDamage * lv_quadraticEquation);
    }
    else {
        return lp_guillotineBaseDamage;
    }
}

// Triggers
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Zul'jin - Player Setup
//--------------------------------------------------------------------------------------------------
bool libHZUL_gt_HeroZuljinPlayerSetup_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((UnitGetType(libGame_gv_players[libGame_gf_HeroSpawnPlayer()].lv_heroUnit) == "HeroZuljin"))) {
            return false;
        }
    }

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

    libHZUL_gf_ZuljinGuillotineDamageMonitor(libGame_gf_HeroSpawnPlayer());
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHZUL_gt_HeroZuljinPlayerSetup_Init () {
    libHZUL_gt_HeroZuljinPlayerSetup = TriggerCreate("libHZUL_gt_HeroZuljinPlayerSetup_Func");
    TriggerEnable(libHZUL_gt_HeroZuljinPlayerSetup, false);
    libGame_gf_HeroSpawn(libHZUL_gt_HeroZuljinPlayerSetup);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Zul'jin - UI Initialize
//--------------------------------------------------------------------------------------------------
bool libHZUL_gt_HeroZuljinUIInitialize_Func (bool testConds, bool runActions) {
    int init_i;

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

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

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

    DialogControlHookup(libUIUI_gv_heroSpecificStatusContainer, c_triggerControlTypePanel, "ZuljinTraitFrame");
    libHZUL_gv_zuljinUI.lv_mainPanel = DialogControlLastCreated();
    lv_currentPanelLayer += 1;
    lv_panel[lv_currentPanelLayer] = DialogControlLastCreated();
    DialogControlHookup(lv_panel[lv_currentPanelLayer], c_triggerControlTypeLabel, "UnitStatusFrame0/ZuljinGuillotineValueLabel");
    libHZUL_gv_zuljinUI.lv_guillotineDamageLabel = DialogControlLastCreated();
    DialogControlSetVisible(libHZUL_gv_zuljinUI.lv_guillotineDamageLabel, PlayerGroupAll(), false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHZUL_gt_HeroZuljinUIInitialize_Init () {
    libHZUL_gt_HeroZuljinUIInitialize = TriggerCreate("libHZUL_gt_HeroZuljinUIInitialize_Func");
    libCore_gf_IncludeModInitialization(libHZUL_gt_HeroZuljinUIInitialize);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Zul'jin - UI Clean Up - Guillotine
//--------------------------------------------------------------------------------------------------
bool libHZUL_gt_HeroZuljinUICleanUpGuillotine_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    DialogControlSetVisible(libHZUL_gv_zuljinUI.lv_guillotineDamageLabel, libCore_gv_playerGroupFromPlayer[libGame_gf_HeroRespecsTalentsPlayer()], false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHZUL_gt_HeroZuljinUICleanUpGuillotine_Init () {
    libHZUL_gt_HeroZuljinUICleanUpGuillotine = TriggerCreate("libHZUL_gt_HeroZuljinUICleanUpGuillotine_Func");
    TriggerEnable(libHZUL_gt_HeroZuljinUICleanUpGuillotine, false);
    libGame_gf_HeroRespecsTalents(libHZUL_gt_HeroZuljinUICleanUpGuillotine);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Zul'jin - You Want Axe Score Value
//--------------------------------------------------------------------------------------------------
bool libHZUL_gt_HeroZuljinYouWantAxeScoreValue_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_caster;
    int lv_player;
    fixed lv_scoreValue;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_caster = EventPlayerEffectUsedUnit(c_effectUnitCaster);
    lv_player = UnitGetOwner(lv_caster);
    lv_scoreValue = ((UnitGetTokenCount(lv_caster, "ZuljinYouWantAxeQuestMainToken") * CatalogFieldValueGetAsFixed(c_gameCatalogBehavior, "ZuljinYouWantAxeQuestMiniProgressToken", "Max", lv_player)) + UnitGetTokenCount(lv_caster, "ZuljinYouWantAxeQuestMiniProgressToken"));

    // Conditions
    if (testConds) {
        if (!((lv_scoreValue <= (CatalogFieldValueGetAsInt(c_gameCatalogBehavior, "ZuljinYouWantAxeQuestMainToken", "ConditionalEvents[" + IntToString(1) + "].CompareValue", 0) * CatalogFieldValueGetAsInt(c_gameCatalogBehavior, "ZuljinYouWantAxeQuestMiniProgressToken", "Max", 0))))) {
            return false;
        }
    }

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

    PlayerScoreValueSetFromFixed(lv_player, "ZuljinYouWantAxeScoreValue", lv_scoreValue);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHZUL_gt_HeroZuljinYouWantAxeScoreValue_Init () {
    libHZUL_gt_HeroZuljinYouWantAxeScoreValue = TriggerCreate("libHZUL_gt_HeroZuljinYouWantAxeScoreValue_Func");
    TriggerEnable(libHZUL_gt_HeroZuljinYouWantAxeScoreValue, false);
    TriggerAddEventPlayerEffectUsed(libHZUL_gt_HeroZuljinYouWantAxeScoreValue, c_playerAny, "ZuljinYouWantAxeQuestIncrementMiniProgressToken");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Zul'jin - You Want Axe Score Value Reset
//--------------------------------------------------------------------------------------------------
bool libHZUL_gt_HeroZuljinYouWantAxeScoreValueReset_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_unit;
    int lv_player;

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

    // Conditions
    if (testConds) {
        if (!((UnitGetType(lv_unit) == "HeroZuljin"))) {
            return false;
        }
    }

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

    PlayerScoreValueSetFromFixed(lv_player, "ZuljinYouWantAxeScoreValue", 0.0);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHZUL_gt_HeroZuljinYouWantAxeScoreValueReset_Init () {
    libHZUL_gt_HeroZuljinYouWantAxeScoreValueReset = TriggerCreate("libHZUL_gt_HeroZuljinYouWantAxeScoreValueReset_Func");
    TriggerEnable(libHZUL_gt_HeroZuljinYouWantAxeScoreValueReset, false);
    TriggerAddEventUnitCreated(libHZUL_gt_HeroZuljinYouWantAxeScoreValueReset, null, null, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Zul'jin - Berserker - Set Life To 1
//--------------------------------------------------------------------------------------------------
bool libHZUL_gt_HeroZuljinBerserkerSetLifeTo1_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_itUnit;

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

    // Conditions
    if (testConds) {
        if (!((UnitGetPropertyFixed(lv_itUnit, c_unitPropLife, c_unitPropCurrent) < 5.0))) {
            return false;
        }

        if (!((UnitHasBehavior2(lv_itUnit, "ZuljinBerserkerActive") == true))) {
            return false;
        }
    }

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

    UnitSetPropertyFixed(lv_itUnit, c_unitPropLife, 1.0);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHZUL_gt_HeroZuljinBerserkerSetLifeTo1_Init () {
    libHZUL_gt_HeroZuljinBerserkerSetLifeTo1 = TriggerCreate("libHZUL_gt_HeroZuljinBerserkerSetLifeTo1_Func");
    TriggerEnable(libHZUL_gt_HeroZuljinBerserkerSetLifeTo1, false);
    TriggerAddEventPlayerEffectUsed(libHZUL_gt_HeroZuljinBerserkerSetLifeTo1, c_playerAny, "ZuljinBerserkerSetLifeTo1DummySet");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Zul'jin - Guillotine - Cast Modify Damage
//--------------------------------------------------------------------------------------------------
bool libHZUL_gt_HeroZuljinGuillotineCastModifyDamage_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_zuljinPlayer;
    fixed lv_guillotineDamage;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_zuljinPlayer = EventPlayer();
    lv_guillotineDamage = libHZUL_gv_heroZuljinGuillotineTotalDamage[lv_zuljinPlayer];

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

    CatalogFieldValueSetFixed(c_gameCatalogEffect, "ZuljinGuillotineDamage", "Amount", lv_zuljinPlayer, lv_guillotineDamage);
    CatalogFieldValueSetFixed(c_gameCatalogEffect, "ZuljinGuillotineBuzzsawDamage", "Amount", lv_zuljinPlayer, lv_guillotineDamage);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHZUL_gt_HeroZuljinGuillotineCastModifyDamage_Init () {
    libHZUL_gt_HeroZuljinGuillotineCastModifyDamage = TriggerCreate("libHZUL_gt_HeroZuljinGuillotineCastModifyDamage_Func");
    TriggerEnable(libHZUL_gt_HeroZuljinGuillotineCastModifyDamage, false);
    TriggerAddEventPlayerEffectUsed(libHZUL_gt_HeroZuljinGuillotineCastModifyDamage, c_playerAny, "ZuljinGuillotineInitialSet");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Zul'jin - Guillotine - Talent Selected
//--------------------------------------------------------------------------------------------------
bool libHZUL_gt_HeroZuljinGuillotineTalentSelected_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((libGame_gf_HeroGainTalentGainedTalent() == "ZuljinGuillotine"))) {
            return false;
        }
    }

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

    DialogControlSetVisible(libHZUL_gv_zuljinUI.lv_guillotineDamageLabel, PlayerGroupSingle(libGame_gf_HeroGainTalentPlayer()), true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHZUL_gt_HeroZuljinGuillotineTalentSelected_Init () {
    libHZUL_gt_HeroZuljinGuillotineTalentSelected = TriggerCreate("libHZUL_gt_HeroZuljinGuillotineTalentSelected_Func");
    TriggerEnable(libHZUL_gt_HeroZuljinGuillotineTalentSelected, false);
    libGame_gf_HeroGainTalent(libHZUL_gt_HeroZuljinGuillotineTalentSelected);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Zul'jin - Guillotine - VO Dead Kill
//--------------------------------------------------------------------------------------------------
bool libHZUL_gt_HeroZuljinGuillotineVODeadKill_Func (bool testConds, bool runActions) {
    // Variable Declarations
    string lv_killingEffect;
    int lv_killingPlayer;
    int lv_deadPlayer;
    int lv_speakingPlayer;
    string lv_killLine;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_killingPlayer = libGame_gf_CustomKillVOKillingPlayer();
    lv_deadPlayer = libGame_gf_CustomKillVODeadPlayer();
    lv_speakingPlayer = libGame_gf_CustomKillVOSpeakingPlayer();
    lv_killLine = libGame_gf_CustomKillVOKillLine();

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

        if (!((libGame_gv_players[lv_killingPlayer].lv_isDead == true))) {
            return false;
        }
    }

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

    lv_killingEffect = libGame_gv_deathRecap_DeathData[lv_deadPlayer].lv_effectBars[1].lv_effect;
    if (((lv_killingEffect == "ZuljinGuillotineDamage") || (lv_killingEffect == "ZuljinGuillotineBuzzsawDamage"))) {
        lv_speakingPlayer = lv_killingPlayer;
        lv_killLine = ("ZuljinBase_DeadGuillotine");
    }

    libSond_gf_HeroVOPlayKillLine((lv_killLine), lv_speakingPlayer, lv_killingPlayer);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHZUL_gt_HeroZuljinGuillotineVODeadKill_Init () {
    libHZUL_gt_HeroZuljinGuillotineVODeadKill = TriggerCreate("libHZUL_gt_HeroZuljinGuillotineVODeadKill_Func");
    TriggerEnable(libHZUL_gt_HeroZuljinGuillotineVODeadKill, false);
    libGame_gf_CustomKillVO(libHZUL_gt_HeroZuljinGuillotineVODeadKill);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Zul'jin - Amani Rage Cast
//--------------------------------------------------------------------------------------------------
bool libHZUL_gt_HeroZuljinAmaniRageCast_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_zuljinPlayer;
    unit lv_zuljinUnit;
    fixed lv_currentHealth;
    int lv_amaniRagePeriodCount;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_zuljinPlayer = EventPlayerEffectUsedUnitOwner(c_effectPlayerCaster);
    lv_zuljinUnit = EventPlayerEffectUsedUnit(c_effectUnitCaster);
    lv_currentHealth = (UnitGetPropertyFixed(lv_zuljinUnit, c_unitPropLife, c_unitPropCurrent) / 2.0);
    lv_amaniRagePeriodCount = CatalogFieldValueGetAsInt(c_gameCatalogBehavior, "ZuljinAmaniRageHealBuff", "PeriodCount", lv_zuljinPlayer);

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

    UnitSetPropertyFixed(lv_zuljinUnit, c_unitPropLife, lv_currentHealth);
    CatalogFieldValueModifyFixed(c_gameCatalogEffect, "ZuljinAmaniRageCreateHealer", "RechargeVitalRate", lv_zuljinPlayer, (lv_currentHealth / lv_amaniRagePeriodCount), c_upgradeOperationSet);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHZUL_gt_HeroZuljinAmaniRageCast_Init () {
    libHZUL_gt_HeroZuljinAmaniRageCast = TriggerCreate("libHZUL_gt_HeroZuljinAmaniRageCast_Func");
    TriggerEnable(libHZUL_gt_HeroZuljinAmaniRageCast, false);
    TriggerAddEventPlayerEffectUsed(libHZUL_gt_HeroZuljinAmaniRageCast, c_playerAny, "ZuljinAmaniRageInitialSet");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Zul'jin - Headhunter - Selected
//--------------------------------------------------------------------------------------------------
bool libHZUL_gt_HeroZuljinHeadhunterSelected_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_zuljinPlayer;

    // Automatic Variable Declarations
    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((libGame_gf_HeroGainTalentGainedTalent() == "ZuljinHeadhunter"))) {
            return false;
        }
    }

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

    lv_zuljinPlayer = libGame_gf_HeroGainTalentPlayer();
    while ((TimerGetRemaining(libGame_gv_openTheGatesTimer) >= 30.0)) {
        Wait(1.0, c_timeGame);
    }
    UnitGroupAddUnitGroup(libHZUL_gv_heroZuljinHeadhunterUnitGroupHitList[lv_zuljinPlayer], libGame_gv_players_Heroes_AllTrackedHeroesForTeam[libGame_gf_EnemyTeamNumberOfPlayer(lv_zuljinPlayer)]);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHZUL_gt_HeroZuljinHeadhunterSelected_Init () {
    libHZUL_gt_HeroZuljinHeadhunterSelected = TriggerCreate("libHZUL_gt_HeroZuljinHeadhunterSelected_Func");
    TriggerEnable(libHZUL_gt_HeroZuljinHeadhunterSelected, false);
    libGame_gf_HeroGainTalent(libHZUL_gt_HeroZuljinHeadhunterSelected);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Zul'jin - Headhunter - Progress
//--------------------------------------------------------------------------------------------------
bool libHZUL_gt_HeroZuljinHeadhunterProgress_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_zuljinPlayer;
    unit lv_unit;
    int lv_zuljinEnemyTeam;
    unit lv_killedHero;
    int lv_itPlayer;
    unit lv_itUnit;
    int lv_itViking;

    // Automatic Variable Declarations
    unitgroup auto9A196AC6_g;
    int auto9A196AC6_u;

    // Variable Initialization
    lv_zuljinPlayer = libGame_gf_HeroParticipatedInTakedownKillingPlayer();
    lv_unit = libGame_gv_players[lv_zuljinPlayer].lv_heroUnit;
    lv_zuljinEnemyTeam = libGame_gf_EnemyTeamNumberOfPlayer(lv_zuljinPlayer);
    lv_killedHero = libGame_gf_HeroParticipatedInTakedownKilledHero();

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

        if (!((UnitGroupHasUnit(libHZUL_gv_heroZuljinHeadhunterUnitGroupVictims[lv_zuljinPlayer], lv_killedHero) == false))) {
            return false;
        }

        if (!((UnitGroupHasUnit(libGame_gv_players_Heroes_AllTrackedHeroesForTeam[lv_zuljinEnemyTeam], lv_killedHero) == true))) {
            return false;
        }

        if (!((UnitGroupCount(libHZUL_gv_heroZuljinHeadhunterUnitGroupVictims[lv_zuljinPlayer], c_unitCountAll) != UnitGroupCount(libGame_gv_players_Heroes_AllTrackedHeroesForTeam[lv_zuljinEnemyTeam], c_unitCountAll)))) {
            return false;
        }
    }

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

    UnitGroupRemove(libHZUL_gv_heroZuljinHeadhunterUnitGroupHitList[lv_zuljinPlayer], lv_killedHero);
    UnitGroupAdd(libHZUL_gv_heroZuljinHeadhunterUnitGroupVictims[lv_zuljinPlayer], lv_killedHero);
    if (((UnitGetType(lv_killedHero) == "HeroErik") || (UnitGetType(lv_killedHero) == "HeroBaleog") || (UnitGetType(lv_killedHero) == "HeroOlaf"))) {
        auto9A196AC6_g = libHZUL_gv_heroZuljinHeadhunterUnitGroupVictims[lv_zuljinPlayer];
        auto9A196AC6_u = UnitGroupCount(auto9A196AC6_g, c_unitCountAll);
        for (;; auto9A196AC6_u -= 1) {
            lv_itUnit = UnitGroupUnitFromEnd(auto9A196AC6_g, auto9A196AC6_u);
            if (lv_itUnit == null) { break; }
            if (((UnitGetType(lv_itUnit) == "HeroErik") || (UnitGetType(lv_itUnit) == "HeroBaleog") || (UnitGetType(lv_itUnit) == "HeroOlaf"))) {
                lv_itViking += 1;
            }

        }
        if ((lv_itViking == 3)) {
            UnitCreateEffectUnit(lv_unit, "ZuljinHeadhunterQuestIncrementToken", lv_unit);
        }

    }
    else {
        UnitCreateEffectUnit(lv_unit, "ZuljinHeadhunterQuestIncrementToken", lv_unit);
    }
    if ((UnitGetType(lv_killedHero) == "HeroCho")) {
        UnitCreateEffectUnit(lv_unit, "ZuljinHeadhunterQuestIncrementToken", lv_unit);
    }

    if ((libCore_gv_sYSGameMode == libCore_ge_GameModes_TryMe) && (UnitGroupCount(libHZUL_gv_heroZuljinHeadhunterUnitGroupVictims[lv_zuljinPlayer], c_unitCountAll) == UnitGroupCount(libGame_gv_players_Heroes_AllTrackedHeroesForTeam[lv_zuljinEnemyTeam], c_unitCountAll))) {
        UnitCreateEffectUnit(lv_unit, "ZuljinHeadhunterQuestIncrementToken", lv_unit);
        UnitCreateEffectUnit(lv_unit, "ZuljinHeadhunterQuestIncrementToken", lv_unit);
        UnitCreateEffectUnit(lv_unit, "ZuljinHeadhunterQuestIncrementToken", lv_unit);
        UnitCreateEffectUnit(lv_unit, "ZuljinHeadhunterQuestIncrementToken", lv_unit);
        UnitCreateEffectUnit(lv_unit, "ZuljinHeadhunterQuestIncrementToken", lv_unit);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libHZUL_gt_HeroZuljinHeadhunterProgress_Init () {
    libHZUL_gt_HeroZuljinHeadhunterProgress = TriggerCreate("libHZUL_gt_HeroZuljinHeadhunterProgress_Func");
    TriggerEnable(libHZUL_gt_HeroZuljinHeadhunterProgress, false);
    libGame_gf_HeroParticipatedInTakedown(libHZUL_gt_HeroZuljinHeadhunterProgress);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Zul'jin - Headhunter - Respec
//--------------------------------------------------------------------------------------------------
bool libHZUL_gt_HeroZuljinHeadhunterRespec_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_itPlayer;
    unit lv_unit;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_itPlayer = libGame_gf_HeroRespecsTalentsPlayer();
    lv_unit = libGame_gv_players[lv_itPlayer].lv_heroUnit;

    // Conditions
    if (testConds) {
        if (!((UnitGetType(lv_unit) == "HeroZuljin"))) {
            return false;
        }
    }

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

    UnitGroupClear(libHZUL_gv_heroZuljinHeadhunterUnitGroupVictims[lv_itPlayer]);
    UnitGroupClear(libHZUL_gv_heroZuljinHeadhunterUnitGroupHitList[lv_itPlayer]);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHZUL_gt_HeroZuljinHeadhunterRespec_Init () {
    libHZUL_gt_HeroZuljinHeadhunterRespec = TriggerCreate("libHZUL_gt_HeroZuljinHeadhunterRespec_Func");
    TriggerEnable(libHZUL_gt_HeroZuljinHeadhunterRespec, false);
    libGame_gf_HeroRespecsTalents(libHZUL_gt_HeroZuljinHeadhunterRespec);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Zul'jin - Let The Killing Begin - Refresh Duration
//--------------------------------------------------------------------------------------------------
bool libHZUL_gt_HeroZuljinLetTheKillingBeginRefreshDuration_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_itUnit;

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

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

        if (!((UnitHasBehavior2(lv_itUnit, "ZuljinLetTheKillingBeginStack") == true))) {
            return false;
        }
    }

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

    UnitBehaviorSetDuration(lv_itUnit, "ZuljinLetTheKillingBeginStack", CatalogFieldValueGetAsInt(c_gameCatalogBehavior, "ZuljinLetTheKillingBeginStack", "Duration", EventPlayer()));
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHZUL_gt_HeroZuljinLetTheKillingBeginRefreshDuration_Init () {
    libHZUL_gt_HeroZuljinLetTheKillingBeginRefreshDuration = TriggerCreate("libHZUL_gt_HeroZuljinLetTheKillingBeginRefreshDuration_Func");
    TriggerEnable(libHZUL_gt_HeroZuljinLetTheKillingBeginRefreshDuration, false);
    TriggerAddEventPlayerEffectUsed(libHZUL_gt_HeroZuljinLetTheKillingBeginRefreshDuration, c_playerAny, "ZuljinLetTheKillingBeginDummyRefreshBehaviorDuration");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Zul'jin - Let The Killing Begin - Hero Takedown
//--------------------------------------------------------------------------------------------------
bool libHZUL_gt_HeroZuljinLetTheKillingBeginHeroTakedown_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_player;
    unit lv_unit;
    unit lv_vehicle;

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

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

        if (!(((UnitGetType(lv_unit) == "HeroZuljin") || (UnitGetType(lv_vehicle) == "HeroZuljin")))) {
            return false;
        }
    }

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

    UnitCreateEffectUnit(lv_unit, "ZuljinLetTheKillingBeginApplyHeroStackBehavior", lv_unit);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHZUL_gt_HeroZuljinLetTheKillingBeginHeroTakedown_Init () {
    libHZUL_gt_HeroZuljinLetTheKillingBeginHeroTakedown = TriggerCreate("libHZUL_gt_HeroZuljinLetTheKillingBeginHeroTakedown_Func");
    TriggerEnable(libHZUL_gt_HeroZuljinLetTheKillingBeginHeroTakedown, false);
    libGame_gf_HeroParticipatedInTakedown(libHZUL_gt_HeroZuljinLetTheKillingBeginHeroTakedown);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Zul'jin - Ferocity - Update Accumulator
//--------------------------------------------------------------------------------------------------
bool libHZUL_gt_HeroZuljinFerocityUpdateAccumulator_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_zuljinPlayer;
    unit lv_zuljinUnit;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_zuljinPlayer = libGame_gf_HeroGainTalentPlayer();
    lv_zuljinUnit = libGame_gv_players[lv_zuljinPlayer].lv_heroUnit;

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

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

    CatalogFieldValueSet(c_gameCatalogBehavior, "ZuljinBerserkerPassive", "Modification.AdditiveAttackSpeedFactor.AccumulatorArray[" + IntToString(0) + "]", lv_zuljinPlayer, "ZuljinBerserkerFerocityHealthToAttackSpeed");
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHZUL_gt_HeroZuljinFerocityUpdateAccumulator_Init () {
    libHZUL_gt_HeroZuljinFerocityUpdateAccumulator = TriggerCreate("libHZUL_gt_HeroZuljinFerocityUpdateAccumulator_Func");
    TriggerEnable(libHZUL_gt_HeroZuljinFerocityUpdateAccumulator, false);
    libGame_gf_HeroGainTalent(libHZUL_gt_HeroZuljinFerocityUpdateAccumulator);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Zul'jin - Ferocity - Respec
//--------------------------------------------------------------------------------------------------
bool libHZUL_gt_HeroZuljinFerocityRespec_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_zuljinPlayer;
    unit lv_unit;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_zuljinPlayer = libGame_gf_HeroRespecsTalentsPlayer();
    lv_unit = libGame_gv_players[lv_zuljinPlayer].lv_heroUnit;

    // Conditions
    if (testConds) {
        if (!((UnitGetType(lv_unit) == "HeroZuljin"))) {
            return false;
        }
    }

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

    CatalogFieldValueSet(c_gameCatalogBehavior, "ZuljinBerserkerPassive", "Modification.AdditiveAttackSpeedFactor.AccumulatorArray[" + IntToString(0) + "]", lv_zuljinPlayer, "ZuljinBerserkerHealthToAttackSpeed");
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHZUL_gt_HeroZuljinFerocityRespec_Init () {
    libHZUL_gt_HeroZuljinFerocityRespec = TriggerCreate("libHZUL_gt_HeroZuljinFerocityRespec_Func");
    TriggerEnable(libHZUL_gt_HeroZuljinFerocityRespec, false);
    libGame_gf_HeroRespecsTalents(libHZUL_gt_HeroZuljinFerocityRespec);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Zul'jin - Amani Resilience - On
//--------------------------------------------------------------------------------------------------
bool libHZUL_gt_HeroZuljinAmaniResilienceOn_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((PlayerHasTalent(UnitGetOwner(EventUnit()), "ZuljinAmaniResilience") == true))) {
            return false;
        }
    }

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

    TriggerEnable(libHZUL_gt_HeroZuljinAmaniResilienceDamageTracker, true);
    libHZUL_gv_heroZuljinAmaniResilienceCastCount += 1;
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHZUL_gt_HeroZuljinAmaniResilienceOn_Init () {
    libHZUL_gt_HeroZuljinAmaniResilienceOn = TriggerCreate("libHZUL_gt_HeroZuljinAmaniResilienceOn_Func");
    TriggerEnable(libHZUL_gt_HeroZuljinAmaniResilienceOn, false);
    TriggerAddEventUnitBehaviorChange(libHZUL_gt_HeroZuljinAmaniResilienceOn, null, "ZuljinTazdingoUnkillable", c_unitBehaviorChangeActivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Zul'jin - Amani Resilience - Damage Tracker
//--------------------------------------------------------------------------------------------------
bool libHZUL_gt_HeroZuljinAmaniResilienceDamageTracker_Func (bool testConds, bool runActions) {
    // Variable Declarations
    fixed lv_damageAmount;
    const fixed lv_damageDealtHealingFraction = 0.5;
    unit lv_itUnit;
    int lv_itPlayer;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_itUnit = EventUnitDamageSourceUnit();
    lv_itPlayer = UnitGetOwner(EventUnitDamageSourceUnit());

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

        if (!((PlayerHasTalent(lv_itPlayer, "ZuljinAmaniResilience") == true))) {
            return false;
        }
    }

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

    if (((lv_itPlayer > libCore_gv_bALMaxPlayers) || (lv_itPlayer <= 0))) {
        return true;
    }

    lv_damageAmount = ((EventUnitDamageAmount() + EventUnitDamageBehaviorShield()) * lv_damageDealtHealingFraction);
    libHZUL_gv_heroZuljinAmaniResilienceCombinedHeal[lv_itPlayer] += lv_damageAmount;
    libHZUL_gv_heroZuljinAmaniResilienceHealPreviewCombinedDamage[UnitGetOwner(lv_itUnit)] += lv_damageAmount;
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHZUL_gt_HeroZuljinAmaniResilienceDamageTracker_Init () {
    libHZUL_gt_HeroZuljinAmaniResilienceDamageTracker = TriggerCreate("libHZUL_gt_HeroZuljinAmaniResilienceDamageTracker_Func");
    TriggerEnable(libHZUL_gt_HeroZuljinAmaniResilienceDamageTracker, false);
    TriggerAddDamageEvent(libHZUL_gt_HeroZuljinAmaniResilienceDamageTracker, "HeroZuljin", null, c_unitDamageTypeAny, c_unitDamageEither, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Zul'jin - Amani Resilience - Heal Preview Catalog
//--------------------------------------------------------------------------------------------------
bool libHZUL_gt_HeroZuljinAmaniResilienceHealPreviewCatalog_Func (bool testConds, bool runActions) {
    // Variable Declarations
    fixed lv_duration;
    unit lv_itUnit;
    int lv_itPlayer;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_duration = 4.0;
    lv_itUnit = EventPlayerEffectUsedUnit(c_effectUnitCaster);
    lv_itPlayer = UnitGetOwner(lv_itUnit);

    // Conditions
    if (testConds) {
        if (!((UnitGetType(EventPlayerEffectUsedUnit(c_effectUnitCaster)) == "HeroZuljin"))) {
            return false;
        }

        if (!((UnitHasBehavior2(EventPlayerEffectUsedUnit(c_effectUnitCaster), "ZuljinTazdingoAmaniResilienceDamageTracker") == true))) {
            return false;
        }
    }

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

    if ((UnitBehaviorCount(lv_itUnit, "ZuljinTazdingoAmaniResilienceHealPreviewTracker") == 0)) {
        UnitBehaviorAdd(lv_itUnit, "ZuljinTazdingoAmaniResilienceHealPreviewTracker", lv_itUnit, 1);
    }

    CatalogFieldValueSetFixed(c_gameCatalogEffect, "ZuljinTazdingoAmaniResilienceDummyTrackerCreateHealer", "RechargeVitalRate", lv_itPlayer, libHZUL_gv_heroZuljinAmaniResilienceHealPreviewCombinedDamage[lv_itPlayer]);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHZUL_gt_HeroZuljinAmaniResilienceHealPreviewCatalog_Init () {
    libHZUL_gt_HeroZuljinAmaniResilienceHealPreviewCatalog = TriggerCreate("libHZUL_gt_HeroZuljinAmaniResilienceHealPreviewCatalog_Func");
    TriggerEnable(libHZUL_gt_HeroZuljinAmaniResilienceHealPreviewCatalog, false);
    TriggerAddEventPlayerEffectUsed(libHZUL_gt_HeroZuljinAmaniResilienceHealPreviewCatalog, c_playerAny, "ZuljinTazdingoAmaniResilienceDummyStartSet");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Zul'jin - Amani Resilience - Off
//--------------------------------------------------------------------------------------------------
bool libHZUL_gt_HeroZuljinAmaniResilienceOff_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_itUnit;
    int lv_itPlayer;
    fixed lv_healAmount;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_itUnit = EventUnit();
    lv_itPlayer = UnitGetOwner(lv_itUnit);
    lv_healAmount = libHZUL_gv_heroZuljinAmaniResilienceCombinedHeal[lv_itPlayer];

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

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

    libHZUL_gv_heroZuljinAmaniResilienceCastCount -= 1;
    if ((libHZUL_gv_heroZuljinAmaniResilienceCastCount == 0)) {
        TriggerEnable(libHZUL_gt_HeroZuljinAmaniResilienceDamageTracker, false);
    }

    CatalogFieldValueSetFixed(c_gameCatalogEffect, "ZuljinTazdingoAmaniResilienceCreateHealer", "RechargeVitalRate", lv_itPlayer, lv_healAmount);
    CatalogFieldValueSet(c_gameCatalogEffect, "ZuljinTazdingoAmaniResilienceDummyTrackerCreateHealer", "RechargeVitalRate", lv_itPlayer, "0");
    UnitCreateEffectUnit(lv_itUnit, "ZuljinTazdingoAmaniResilienceCreateHealer", lv_itUnit);
    libHZUL_gv_heroZuljinAmaniResilienceCombinedHeal[lv_itPlayer] = 0.0;
    libHZUL_gv_heroZuljinAmaniResilienceHealPreviewCombinedDamage[lv_itPlayer] = 0.0;
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHZUL_gt_HeroZuljinAmaniResilienceOff_Init () {
    libHZUL_gt_HeroZuljinAmaniResilienceOff = TriggerCreate("libHZUL_gt_HeroZuljinAmaniResilienceOff_Func");
    TriggerEnable(libHZUL_gt_HeroZuljinAmaniResilienceOff, false);
    TriggerAddEventUnitBehaviorChange(libHZUL_gt_HeroZuljinAmaniResilienceOff, null, "ZuljinTazdingoAmaniResilienceDamageTracker", c_unitBehaviorChangeDeactivate);
}

void libHZUL_InitTriggers () {
    libHZUL_gt_HeroZuljinPlayerSetup_Init();
    libHZUL_gt_HeroZuljinUIInitialize_Init();
    libHZUL_gt_HeroZuljinUICleanUpGuillotine_Init();
    libHZUL_gt_HeroZuljinYouWantAxeScoreValue_Init();
    libHZUL_gt_HeroZuljinYouWantAxeScoreValueReset_Init();
    libHZUL_gt_HeroZuljinBerserkerSetLifeTo1_Init();
    libHZUL_gt_HeroZuljinGuillotineCastModifyDamage_Init();
    libHZUL_gt_HeroZuljinGuillotineTalentSelected_Init();
    libHZUL_gt_HeroZuljinGuillotineVODeadKill_Init();
    libHZUL_gt_HeroZuljinAmaniRageCast_Init();
    libHZUL_gt_HeroZuljinHeadhunterSelected_Init();
    libHZUL_gt_HeroZuljinHeadhunterProgress_Init();
    libHZUL_gt_HeroZuljinHeadhunterRespec_Init();
    libHZUL_gt_HeroZuljinLetTheKillingBeginRefreshDuration_Init();
    libHZUL_gt_HeroZuljinLetTheKillingBeginHeroTakedown_Init();
    libHZUL_gt_HeroZuljinFerocityUpdateAccumulator_Init();
    libHZUL_gt_HeroZuljinFerocityRespec_Init();
    libHZUL_gt_HeroZuljinAmaniResilienceOn_Init();
    libHZUL_gt_HeroZuljinAmaniResilienceDamageTracker_Init();
    libHZUL_gt_HeroZuljinAmaniResilienceHealPreviewCatalog_Init();
    libHZUL_gt_HeroZuljinAmaniResilienceOff_Init();
}

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

void libHZUL_InitLib () {
    if (libHZUL_InitLib_completed) {
        return;
    }

    libHZUL_InitLib_completed = true;

    libHZUL_InitLibraries();
    libHZUL_InitVariables();
    libHZUL_InitTriggers();
}