PTR build 2.57.1.98674_ptr. Go to the live site.

mods/heromods/stukov.stormmod/base.stormdata/libhstu.galaxy

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

include "LibHSTU_h"

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

// Variable Initialization
bool libHSTU_InitVariables_completed = false;

void libHSTU_InitVariables () {
    if (libHSTU_InitVariables_completed) {
        return;
    }

    libHSTU_InitVariables_completed = true;

    libHSTU_gv_stukov_MassiveShove_FailsafeDistance = 0.25;
    libHSTU_gv_stukovUI.lv_pathogenFrame = c_invalidDialogControlId;
}

// Functions
void libHSTU_gf_HeroStukovIncrementHeroCountFunction () {
    // Automatic Variable Declarations
    // Implementation
    libHSTU_gv_heroStukovTriggerRegistrationVariable += 1;
    if ((libHSTU_gv_heroStukovTriggerRegistrationVariable == 1)) {
        TriggerEnable(libHSTU_gt_StukovMassiveShoveImpactFailsafe, true);
        TriggerEnable(libHSTU_gt_StukovMassiveShoveDisplacementCamera, true);
        TriggerEnable(libHSTU_gt_StukovMassiveShoveRevealPersistent, true);
        TriggerEnable(libHSTU_gt_SendBioKillSwitchAnimationEvent, true);
        TriggerEnable(libHSTU_gt_StukovSuperstrainHealonStun, true);
    }

}

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

    if ((libHSTU_gv_heroStukovTriggerRegistrationVariable == 0)) {
        TriggerEnable(libHSTU_gt_StukovMassiveShoveImpactFailsafe, false);
        TriggerEnable(libHSTU_gt_StukovMassiveShoveDisplacementCamera, false);
        TriggerEnable(libHSTU_gt_StukovMassiveShoveRevealPersistent, false);
        TriggerEnable(libHSTU_gt_SendBioKillSwitchAnimationEvent, false);
        TriggerEnable(libHSTU_gt_StukovSuperstrainHealonStun, false);
    }

}

// Triggers
//--------------------------------------------------------------------------------------------------
// Trigger: Stukov - Superstrain - Heal on Stun
//--------------------------------------------------------------------------------------------------
bool libHSTU_gt_StukovSuperstrainHealonStun_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_healingPathogenUnit;
    unit lv_stukov;

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

    // Conditions
    if (testConds) {
        if (!((UnitHasBehaviorWithCategoryFlag(lv_healingPathogenUnit, c_behaviorCategoryBuffUnstoppable) == false))) {
            return false;
        }

        if (!((UnitHasBehavior2(lv_healingPathogenUnit, "StukovHealingPathogenHealerBehavior") == true))) {
            return false;
        }

        if (!((!(((EventUnitBehavior() == "ImperiusCelestialChargeFinalStunDebuff") || (EventUnitBehavior() == "DiabloOverpowerStun")))))) {
            return false;
        }
    }

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

    lv_stukov = UnitBehaviorEffectUnit(lv_healingPathogenUnit, "StukovHealingPathogenHealerBehavior", c_effectUnitCaster, 0);
    if ((PlayerHasTalent(UnitGetOwner(lv_stukov), "StukovSuperstrain") == true)) {
        UnitCreateEffectUnit(lv_stukov, "StukovHealingPathogenSuperstrainHealer", lv_healingPathogenUnit);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libHSTU_gt_StukovSuperstrainHealonStun_Init () {
    libHSTU_gt_StukovSuperstrainHealonStun = TriggerCreate("libHSTU_gt_StukovSuperstrainHealonStun_Func");
    TriggerEnable(libHSTU_gt_StukovSuperstrainHealonStun, false);
    TriggerAddEventUnitBehaviorChangeFromCategory(libHSTU_gt_StukovSuperstrainHealonStun, null, c_behaviorCategoryStun, c_unitBehaviorChangeCreate);
    TriggerAddEventUnitBehaviorChangeFromCategory(libHSTU_gt_StukovSuperstrainHealonStun, null, c_behaviorCategoryDebuffRoot, c_unitBehaviorChangeCreate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Stukov - Massive Shove - Impact Failsafe
//--------------------------------------------------------------------------------------------------
bool libHSTU_gt_StukovMassiveShoveImpactFailsafe_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_shoveTarget;
    point lv_shoveTargetCurrentPosition;
    point lv_shoveTargetRecordedPosition;
    bool lv_shoveTargetNotMoving;

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

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

    while ((UnitHasBehavior2(lv_shoveTarget, "StukovMassiveShoveShovedBehavior") == true)) {
        if ((lv_shoveTargetRecordedPosition != null)) {
            lv_shoveTargetCurrentPosition = UnitGetPosition(lv_shoveTarget);
            if ((lv_shoveTargetNotMoving == true)) {
                if ((DistanceBetweenPoints(lv_shoveTargetCurrentPosition, lv_shoveTargetRecordedPosition) < libHSTU_gv_stukov_MassiveShove_FailsafeDistance)) {
                    UnitBehaviorRemove(lv_shoveTarget, "StukovMassiveShoveShovedBehavior", 1);
                    break;
                }

            }
            else {
                if ((DistanceBetweenPoints(lv_shoveTargetCurrentPosition, lv_shoveTargetRecordedPosition) < libHSTU_gv_stukov_MassiveShove_FailsafeDistance)) {
                    lv_shoveTargetNotMoving = true;
                }

            }
        }

        lv_shoveTargetRecordedPosition = UnitGetPosition(lv_shoveTarget);
        Wait(0.0625, c_timeGame);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHSTU_gt_StukovMassiveShoveImpactFailsafe_Init () {
    libHSTU_gt_StukovMassiveShoveImpactFailsafe = TriggerCreate("libHSTU_gt_StukovMassiveShoveImpactFailsafe_Func");
    TriggerEnable(libHSTU_gt_StukovMassiveShoveImpactFailsafe, false);
    TriggerAddEventUnitBehaviorChange(libHSTU_gt_StukovMassiveShoveImpactFailsafe, null, "StukovMassiveShoveShovedBehavior", c_unitBehaviorChangeActivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Stukov - Massive Shove - Displacement Camera
//--------------------------------------------------------------------------------------------------
bool libHSTU_gt_StukovMassiveShoveDisplacementCamera_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_player;

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

    // Conditions
    if (testConds) {
        if (!(((UnitGetOwner(EventUnit()) >= 1) && (UnitGetOwner(EventUnit()) <= 10) && (EventUnit() == libGame_gv_players[lv_player].lv_heroUnit) && (UnitIsAlive(EventUnit()) == true)))) {
            return false;
        }
    }

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

    libGame_gf_PlayerHeroDisplacementCameraLock(EventUnit(), EventUnitBehavior());
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHSTU_gt_StukovMassiveShoveDisplacementCamera_Init () {
    libHSTU_gt_StukovMassiveShoveDisplacementCamera = TriggerCreate("libHSTU_gt_StukovMassiveShoveDisplacementCamera_Func");
    TriggerEnable(libHSTU_gt_StukovMassiveShoveDisplacementCamera, false);
    TriggerAddEventUnitBehaviorChange(libHSTU_gt_StukovMassiveShoveDisplacementCamera, null, "StukovMassiveShoveShovedBehavior", c_unitBehaviorChangeActivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Stukov - Massive Shove - Reveal Persistent
//--------------------------------------------------------------------------------------------------
bool libHSTU_gt_StukovMassiveShoveRevealPersistent_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_stukovPlayer;
    int lv_targetedPlayer;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_stukovPlayer = UnitGetOwner(EventPlayerEffectUsedUnit(c_effectUnitCaster));
    lv_targetedPlayer = UnitGetOwner(EventPlayerEffectUsedUnit(c_effectUnitTarget));

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

    UnitCreateEffectPoint(EventPlayerEffectUsedUnit(c_effectUnitTarget), "StukovMassiveShoveRevealPersistent", EventPlayerEffectUsedPoint(c_effectLocationTargetUnit));
    UnitCreateEffectPoint(EventPlayerEffectUsedUnit(c_effectUnitTarget), "StukovMassiveShoveRevealPersistent", EventPlayerEffectUsedPoint(c_effectLocationCasterUnit));
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHSTU_gt_StukovMassiveShoveRevealPersistent_Init () {
    libHSTU_gt_StukovMassiveShoveRevealPersistent = TriggerCreate("libHSTU_gt_StukovMassiveShoveRevealPersistent_Func");
    TriggerEnable(libHSTU_gt_StukovMassiveShoveRevealPersistent, false);
    TriggerAddEventPlayerEffectUsed(libHSTU_gt_StukovMassiveShoveRevealPersistent, c_playerAny, "StukovMassiveShoveRevealPersistent");
}

//--------------------------------------------------------------------------------------------------
// Trigger: UI - Stukov - Initialize
//--------------------------------------------------------------------------------------------------
bool libHSTU_gt_UIStukovInitialize_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    DialogControlHookup(libUIUI_gv_heroSpecificStatusContainer, c_triggerControlTypePanel, "StukovFrame");
    libHSTU_gv_stukovUI.lv_pathogenFrame = DialogControlLastCreated();
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHSTU_gt_UIStukovInitialize_Init () {
    libHSTU_gt_UIStukovInitialize = TriggerCreate("libHSTU_gt_UIStukovInitialize_Func");
    libCore_gf_IncludeModInitialization(libHSTU_gt_UIStukovInitialize);
}

//--------------------------------------------------------------------------------------------------
// Trigger: UI - Stukov - Trigger Bio Kill Switch Animation
//--------------------------------------------------------------------------------------------------
bool libHSTU_gt_SendBioKillSwitchAnimationEvent_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    DialogControlSendAnimationEvent(libHSTU_gv_stukovUI.lv_pathogenFrame, PlayerGroupSingle(UnitGetOwner(EventUnit())), "BioKillSwitch");
    return true;
}

//--------------------------------------------------------------------------------------------------
void libHSTU_gt_SendBioKillSwitchAnimationEvent_Init () {
    libHSTU_gt_SendBioKillSwitchAnimationEvent = TriggerCreate("libHSTU_gt_SendBioKillSwitchAnimationEvent_Func");
    TriggerEnable(libHSTU_gt_SendBioKillSwitchAnimationEvent, false);
    TriggerAddEventUnitAbility(libHSTU_gt_SendBioKillSwitchAnimationEvent, null, AbilityCommand("StukovBioKillSwitch", 0), c_unitAbilStageComplete, false);
}

void libHSTU_InitTriggers () {
    libHSTU_gt_StukovSuperstrainHealonStun_Init();
    libHSTU_gt_StukovMassiveShoveImpactFailsafe_Init();
    libHSTU_gt_StukovMassiveShoveDisplacementCamera_Init();
    libHSTU_gt_StukovMassiveShoveRevealPersistent_Init();
    libHSTU_gt_UIStukovInitialize_Init();
    libHSTU_gt_SendBioKillSwitchAnimationEvent_Init();
}

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

void libHSTU_InitLib () {
    if (libHSTU_InitLib_completed) {
        return;
    }

    libHSTU_InitLib_completed = true;

    libHSTU_InitLibraries();
    libHSTU_InitVariables();
    libHSTU_InitTriggers();
}