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

}