include "TriggerLibs/NativeLib"
include "TriggerLibs/HeroesLib"
include "TriggerLibs/GameLib"
include "TriggerLibs/MapMechanicsLib"
include "TriggerLibs/AILib"
include "TriggerLibs/UILib"
include "LibHMDV_h"
//--------------------------------------------------------------------------------------------------
// Library: Medivh
//--------------------------------------------------------------------------------------------------
// External Library Initialization
void libHMDV_InitLibraries () {
libNtve_InitVariables();
libCore_InitVariables();
libGame_InitVariables();
libMapM_InitVariables();
libAIAI_InitVariables();
libUIUI_InitVariables();
}
// Variable Initialization
bool libHMDV_InitVariables_completed = false;
void libHMDV_InitVariables () {
int init_i;
if (libHMDV_InitVariables_completed) {
return;
}
libHMDV_InitVariables_completed = true;
for (init_i = 0; init_i <= libCore_gv_bALMaxPlayers; init_i += 1) {
libHMDV_gv_medivhForceofWillPlayerGroup[init_i] = PlayerGroupEmpty();
}
libHMDV_gv_medivhForceOfWillBaseHealMod = 0.2;
libHMDV_gv_medivhForceOfWillReabsorptionTalentHealMod = 0.7;
}
// Functions
void libHMDV_gf_HeroMedivhRavenFamiliartCloakController (unit lp_owningUnit, unit lp_ravenUnit) {
// Automatic Variable Declarations
// Implementation
if (((UnitTestState(lp_owningUnit, c_unitStateCloaked) == true) || (UnitBehaviorCount(lp_owningUnit, "ShrubStatusController") == 1)) && (UnitHasBehavior2(lp_ravenUnit, "MedivhRavenFamiliarCloakingBehavior") == false) && (UnitHasBehavior2(lp_owningUnit, "AttackReveal") == false)) {
UnitBehaviorAdd(lp_ravenUnit, "MedivhRavenFamiliarCloakingBehavior", lp_ravenUnit, 1);
}
else {
if (((UnitBehaviorCount(lp_owningUnit, "ShrubStatusController") == 0) || (UnitHasBehavior2(lp_owningUnit, "AttackReveal") == true)) && (UnitTestState(lp_owningUnit, c_unitStateCloaked) == false) && (UnitHasBehavior2(lp_ravenUnit, "MedivhRavenFamiliarCloakingBehavior") == true)) {
UnitBehaviorRemove(lp_ravenUnit, "MedivhRavenFamiliarCloakingBehavior", 1);
}
}
}
void libHMDV_gf_HeroMedivhIncrementHeroCountFunction () {
// Automatic Variable Declarations
// Implementation
libHMDV_gv_heroMedivhTriggerRegistrationVariable += 1;
if ((libHMDV_gv_heroMedivhTriggerRegistrationVariable == 1)) {
TriggerEnable(libHMDV_gt_HeroMedivhLeyLineSealOverlayOn, true);
TriggerEnable(libHMDV_gt_HeroMedivhRavenFamiliarSpawn, true);
TriggerEnable(libHMDV_gt_HeroMedivhRavenFamiliarPostSpawnCloak, true);
TriggerEnable(libHMDV_gt_HeroMedivhLeyLineSealOverlayOff, true);
TriggerEnable(libHMDV_gt_HeroMedivhPortalCameraPan, false);
TriggerEnable(libHMDV_gt_HeroMedivhPortalPortalMasterySelectionClamping, true);
TriggerEnable(libHMDV_gt_HeroMedivhPortalPortalMasteryMorphBackToMedivh, true);
TriggerEnable(libHMDV_gt_HeroMedivhForceofWillBehaviorResponses, true);
TriggerEnable(libHMDV_gt_HeroMedivhForceofWillRemoveEarly, true);
TriggerEnable(libHMDV_gt_HeroMedivhTransformRavenAfterPortToTown, true);
TriggerEnable(libHMDV_gt_HeroMedivhTransformRavenMountingSpecialCase, true);
TriggerEnable(libHMDV_gt_HeroMedivhTransformSwapToMedivh, true);
TriggerEnable(libHMDV_gt_HeroAIAIMedivhRegisterPortalCast, true);
TriggerEnable(libHMDV_gt_HeroAIMedivhHasCastRavenForm, true);
TriggerEnable(libHMDV_gt_HeroAIMedivhHasLanded, true);
TriggerEnable(libHMDV_gt_HeroAIAIMedivhUnregisterPortal, true);
TriggerEnable(libHMDV_gt_HeroMedivhPortalMasteryCDR, true);
}
}
void libHMDV_gf_HeroMedivhDecrementHeroCountFunction () {
// Automatic Variable Declarations
// Implementation
libHMDV_gv_heroMedivhTriggerRegistrationVariable -= 1;
if ((libHMDV_gv_heroMedivhTriggerRegistrationVariable < 0)) {
libHMDV_gv_heroMedivhTriggerRegistrationVariable = 0;
}
if ((libHMDV_gv_heroMedivhTriggerRegistrationVariable == 0)) {
TriggerEnable(libHMDV_gt_HeroMedivhLeyLineSealOverlayOn, false);
TriggerEnable(libHMDV_gt_HeroMedivhRavenFamiliarSpawn, false);
TriggerEnable(libHMDV_gt_HeroMedivhRavenFamiliarPostSpawnCloak, false);
TriggerEnable(libHMDV_gt_HeroMedivhLeyLineSealOverlayOff, false);
TriggerEnable(libHMDV_gt_HeroMedivhPortalCameraPan, false);
TriggerEnable(libHMDV_gt_HeroMedivhPortalPortalMasterySelectionClamping, false);
TriggerEnable(libHMDV_gt_HeroMedivhPortalPortalMasteryMorphBackToMedivh, false);
TriggerEnable(libHMDV_gt_HeroMedivhForceofWillBehaviorResponses, false);
TriggerEnable(libHMDV_gt_HeroMedivhForceofWillRemoveEarly, false);
TriggerEnable(libHMDV_gt_HeroMedivhTransformRavenAfterPortToTown, false);
TriggerEnable(libHMDV_gt_HeroMedivhTransformRavenMountingSpecialCase, false);
TriggerEnable(libHMDV_gt_HeroMedivhTransformSwapToMedivh, false);
TriggerEnable(libHMDV_gt_HeroAIAIMedivhRegisterPortalCast, false);
TriggerEnable(libHMDV_gt_HeroAIMedivhHasCastRavenForm, false);
TriggerEnable(libHMDV_gt_HeroAIMedivhHasLanded, false);
TriggerEnable(libHMDV_gt_HeroAIAIMedivhUnregisterPortal, false);
TriggerEnable(libHMDV_gt_HeroMedivhPortalMasteryCDR, false);
}
}
unitgroup libHMDV_gf_HeroAIMedivhFindPortalPair (int lp_player) {
// Variable Declarations
unitgroup lv_portalUnitGroup;
// Automatic Variable Declarations
// Variable Initialization
lv_portalUnitGroup = UnitGroupEmpty();
// Implementation
if ((lp_player >= 1) && (lp_player <= libCore_gv_bALMaxPlayers)) {
return libNtve_gf_UnitsInRegionWithAllianceToPlayerMatchingCondition("MedivhPortal", "", "", lp_player, -1, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterSelf) | (1 << c_targetFilterNeutral) | (1 << c_targetFilterEnemy) | (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
}
else {
if ((libCore_gv_dEBUGDebuggingEnabled == true)) {
TriggerDebugOutput(1, StringExternal("Param/Value/lib_HMDV_028E66AC"), true);
}
return null;
}
}
// Triggers
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Medivh - Raven Familiar Spawn
//--------------------------------------------------------------------------------------------------
bool libHMDV_gt_HeroMedivhRavenFamiliarSpawn_Func (bool testConds, bool runActions) {
// Variable Declarations
unit lv_raven;
unit lv_player;
int lv_targetPlayer;
// Automatic Variable Declarations
unitgroup auto8627E677_g;
int auto8627E677_u;
unit auto8627E677_var;
// Variable Initialization
lv_player = EventPlayerEffectUsedUnit(c_effectUnitTarget);
lv_targetPlayer = UnitGetOwner(lv_player);
// Conditions
if (testConds) {
if (!((lv_targetPlayer > 0))) {
return false;
}
if (!((lv_targetPlayer <= libCore_gv_bALMaxPlayers))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
auto8627E677_g = UnitGroup("MedivhPortalRavenFamiliar", lv_targetPlayer, RegionPlayableMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
auto8627E677_u = UnitGroupCount(auto8627E677_g, c_unitCountAll);
for (;; auto8627E677_u -= 1) {
auto8627E677_var = UnitGroupUnitFromEnd(auto8627E677_g, auto8627E677_u);
if (auto8627E677_var == null) { break; }
libHMDV_gf_HeroMedivhRavenFamiliartCloakController(lv_player, auto8627E677_var);
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHMDV_gt_HeroMedivhRavenFamiliarSpawn_Init () {
libHMDV_gt_HeroMedivhRavenFamiliarSpawn = TriggerCreate("libHMDV_gt_HeroMedivhRavenFamiliarSpawn_Func");
TriggerEnable(libHMDV_gt_HeroMedivhRavenFamiliarSpawn, false);
TriggerAddEventPlayerEffectUsed(libHMDV_gt_HeroMedivhRavenFamiliarSpawn, c_playerAny, "MedivhPortalRavenFamiliarCreateUnitPortalAsTarget");
}
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Medivh - Raven Familiar Post Spawn Cloak
//--------------------------------------------------------------------------------------------------
bool libHMDV_gt_HeroMedivhRavenFamiliarPostSpawnCloak_Func (bool testConds, bool runActions) {
// Variable Declarations
unit lv_raven;
unit lv_player;
int lv_targetPlayer;
// Automatic Variable Declarations
unitgroup autoB64B5ADC_g;
int autoB64B5ADC_u;
unit autoB64B5ADC_var;
// Variable Initialization
lv_player = EventUnit();
lv_targetPlayer = UnitGetOwner(lv_player);
// Conditions
if (testConds) {
if (!((lv_targetPlayer > 0))) {
return false;
}
if (!((lv_targetPlayer <= libCore_gv_bALMaxPlayers))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
autoB64B5ADC_g = UnitGroup("MedivhPortalRavenFamiliar", lv_targetPlayer, RegionPlayableMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
autoB64B5ADC_u = UnitGroupCount(autoB64B5ADC_g, c_unitCountAll);
for (;; autoB64B5ADC_u -= 1) {
autoB64B5ADC_var = UnitGroupUnitFromEnd(autoB64B5ADC_g, autoB64B5ADC_u);
if (autoB64B5ADC_var == null) { break; }
libHMDV_gf_HeroMedivhRavenFamiliartCloakController(lv_player, autoB64B5ADC_var);
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHMDV_gt_HeroMedivhRavenFamiliarPostSpawnCloak_Init () {
libHMDV_gt_HeroMedivhRavenFamiliarPostSpawnCloak = TriggerCreate("libHMDV_gt_HeroMedivhRavenFamiliarPostSpawnCloak_Func");
TriggerEnable(libHMDV_gt_HeroMedivhRavenFamiliarPostSpawnCloak, false);
TriggerAddEventUnitBehaviorChangeFromCategory(libHMDV_gt_HeroMedivhRavenFamiliarPostSpawnCloak, null, c_behaviorCategoryTemporaryCloak, c_unitBehaviorChangeAny);
TriggerAddEventUnitBehaviorChangeFromCategory(libHMDV_gt_HeroMedivhRavenFamiliarPostSpawnCloak, null, c_behaviorCategoryPersistentCloak, c_unitBehaviorChangeAny);
TriggerAddEventUnitBehaviorChangeFromCategory(libHMDV_gt_HeroMedivhRavenFamiliarPostSpawnCloak, null, c_behaviorCategoryUnrevealableCloak, c_unitBehaviorChangeAny);
}
//--------------------------------------------------------------------------------------------------
// Trigger: HeroAI - Medivh Has Landed
//--------------------------------------------------------------------------------------------------
bool libHMDV_gt_HeroAIMedivhHasLanded_Func (bool testConds, bool runActions) {
// Automatic Variable Declarations
// Conditions
if (testConds) {
if (!((libAIAI_gf_HeroAIIsAIEnabledForPlayer(UnitGetOwner(EventUnit())) == true))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
AISetSuppressDangerPathing(EventUnit(), false);
return true;
}
//--------------------------------------------------------------------------------------------------
void libHMDV_gt_HeroAIMedivhHasLanded_Init () {
libHMDV_gt_HeroAIMedivhHasLanded = TriggerCreate("libHMDV_gt_HeroAIMedivhHasLanded_Func");
TriggerEnable(libHMDV_gt_HeroAIMedivhHasLanded, false);
TriggerAddEventUnitAbility(libHMDV_gt_HeroAIMedivhHasLanded, null, AbilityCommand("MedivhTransformRavenLand", 0), c_unitAbilStageComplete, false);
}
//--------------------------------------------------------------------------------------------------
// Trigger: HeroAI - Medivh Has Cast Raven Form
//--------------------------------------------------------------------------------------------------
bool libHMDV_gt_HeroAIMedivhHasCastRavenForm_Func (bool testConds, bool runActions) {
// Automatic Variable Declarations
// Conditions
if (testConds) {
if (!((libAIAI_gf_HeroAIIsAIEnabledForPlayer(UnitGetOwner(EventUnit())) == true))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
AISetSuppressDangerPathing(EventUnit(), true);
return true;
}
//--------------------------------------------------------------------------------------------------
void libHMDV_gt_HeroAIMedivhHasCastRavenForm_Init () {
libHMDV_gt_HeroAIMedivhHasCastRavenForm = TriggerCreate("libHMDV_gt_HeroAIMedivhHasCastRavenForm_Func");
TriggerEnable(libHMDV_gt_HeroAIMedivhHasCastRavenForm, false);
TriggerAddEventUnitAbility(libHMDV_gt_HeroAIMedivhHasCastRavenForm, null, AbilityCommand("MedivhTransformRaven", 0), c_unitAbilStageComplete, false);
TriggerAddEventUnitAbility(libHMDV_gt_HeroAIMedivhHasCastRavenForm, null, AbilityCommand("MedivhTransformRavenMorph", 0), c_unitAbilStageComplete, false);
}
//--------------------------------------------------------------------------------------------------
// Trigger: HeroAI - AI Medivh Register Portal Cast
//--------------------------------------------------------------------------------------------------
bool libHMDV_gt_HeroAIAIMedivhRegisterPortalCast_Func (bool testConds, bool runActions) {
// Variable Declarations
int lv_player;
unitgroup lv_portals;
unit lv_portalUnit;
fixed lv_duration;
// Automatic Variable Declarations
// Variable Initialization
lv_portalUnit = EventUnit();
lv_duration = 6.0;
// Actions
if (!runActions) {
return true;
}
Wait(0.0625, c_timeGame);
lv_player = UnitGetOwner(lv_portalUnit);
if ((lv_player > libCore_gv_bALMaxPlayers)) {
return true;
}
lv_portals = libHMDV_gf_HeroAIMedivhFindPortalPair(lv_player);
if ((UnitGroupCount(lv_portals, c_unitCountAlive) != 2)) {
return true;
}
if ((lv_portalUnit == UnitGroupUnit(lv_portals, 1))) {
TriggerDebugOutput(1, StringToText(""), true);
AIAddPortal(libGame_gf_ComputerPlayerInFaction(libGame_gv_players[lv_player].lv_faction), lv_portalUnit, UnitGroupUnit(lv_portals, 2), 0.5, lv_duration, "SmartCommandUnitInteraction", null);
}
else {
TriggerDebugOutput(1, StringToText(""), true);
AIAddPortal(libGame_gf_ComputerPlayerInFaction(libGame_gv_players[lv_player].lv_faction), lv_portalUnit, UnitGroupUnit(lv_portals, 1), 0.5, lv_duration, "SmartCommandUnitInteraction", null);
}
if (((libNtve_gf_UnitInRegion(lv_portalUnit, libMapM_gv_mMSafeRegions[libGame_gv_players[lv_player].lv_faction]) == true) && (libMapM_gv_mMSafeRegions[libGame_gv_players[lv_player].lv_faction] != null))) {
UnitBehaviorAdd(lv_portalUnit, "MedivhPortalNotInHallOfStorms", lv_portalUnit, 1);
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHMDV_gt_HeroAIAIMedivhRegisterPortalCast_Init () {
libHMDV_gt_HeroAIAIMedivhRegisterPortalCast = TriggerCreate("libHMDV_gt_HeroAIAIMedivhRegisterPortalCast_Func");
TriggerEnable(libHMDV_gt_HeroAIAIMedivhRegisterPortalCast, false);
TriggerAddEventUnitBehaviorChange(libHMDV_gt_HeroAIAIMedivhRegisterPortalCast, null, "MedivhPortalTimedLife", c_unitBehaviorChangeCreate);
}
//--------------------------------------------------------------------------------------------------
// Trigger: HeroAI - AI Medivh Unregister Portal
//--------------------------------------------------------------------------------------------------
bool libHMDV_gt_HeroAIAIMedivhUnregisterPortal_Func (bool testConds, bool runActions) {
// Variable Declarations
unitgroup lv_portals;
unit lv_portalUnit;
// Automatic Variable Declarations
// Variable Initialization
lv_portals = libHMDV_gf_HeroAIMedivhFindPortalPair(UnitGetOwner(EventUnit()));
lv_portalUnit = EventUnit();
// Conditions
if (testConds) {
if (!((UnitGroupCount(lv_portals, c_unitCountAlive) == 2))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
AIRemovePortal(lv_portalUnit);
return true;
}
//--------------------------------------------------------------------------------------------------
void libHMDV_gt_HeroAIAIMedivhUnregisterPortal_Init () {
libHMDV_gt_HeroAIAIMedivhUnregisterPortal = TriggerCreate("libHMDV_gt_HeroAIAIMedivhUnregisterPortal_Func");
TriggerEnable(libHMDV_gt_HeroAIAIMedivhUnregisterPortal, false);
TriggerAddEventUnitBehaviorChange(libHMDV_gt_HeroAIAIMedivhUnregisterPortal, null, "MedivhPortalAIUseLink", c_unitBehaviorChangeDecrease);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Medivh - Ley Line Seal Overlay On
//--------------------------------------------------------------------------------------------------
bool libHMDV_gt_HeroMedivhLeyLineSealOverlayOn_Func (bool testConds, bool runActions) {
// Variable Declarations
unit lv_unit;
// Automatic Variable Declarations
// Variable Initialization
lv_unit = EventUnit();
// Actions
if (!runActions) {
return true;
}
if ((UnitIsAlive(lv_unit) == true) && (UnitTestState(lv_unit, c_unitStateHallucination) == false) && (UnitHasBehavior2(lv_unit, "HeroGenericIgnoreFullscreenOverlay") == false)) {
libUIUI_gf_FullscreenOverlayAddItemForPlayer(UnitGetOwner(lv_unit), libUIUI_ge_FullscreenOverlayPriorities_Stasis, "Cutscenes\\GameUI_StasisOverlay.StormCutscene", EventUnitBehavior());
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHMDV_gt_HeroMedivhLeyLineSealOverlayOn_Init () {
libHMDV_gt_HeroMedivhLeyLineSealOverlayOn = TriggerCreate("libHMDV_gt_HeroMedivhLeyLineSealOverlayOn_Func");
TriggerEnable(libHMDV_gt_HeroMedivhLeyLineSealOverlayOn, false);
TriggerAddEventUnitBehaviorChange(libHMDV_gt_HeroMedivhLeyLineSealOverlayOn, null, "MedivhLeyLineSealStasis", c_unitBehaviorChangeActivate);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Medivh - Ley Line Seal Overlay Off
//--------------------------------------------------------------------------------------------------
bool libHMDV_gt_HeroMedivhLeyLineSealOverlayOff_Func (bool testConds, bool runActions) {
// Variable Declarations
unit lv_unit;
// Automatic Variable Declarations
// Variable Initialization
lv_unit = EventUnit();
// Actions
if (!runActions) {
return true;
}
if ((UnitHasBehavior2(lv_unit, "HeroGenericIgnoreFullscreenOverlay") == false)) {
libUIUI_gf_FullscreenOverlayRemoveItemFromQueueForPlayer(UnitGetOwner(lv_unit), "Cutscenes\\GameUI_StasisOverlay.StormCutscene", EventUnitBehavior());
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHMDV_gt_HeroMedivhLeyLineSealOverlayOff_Init () {
libHMDV_gt_HeroMedivhLeyLineSealOverlayOff = TriggerCreate("libHMDV_gt_HeroMedivhLeyLineSealOverlayOff_Func");
TriggerEnable(libHMDV_gt_HeroMedivhLeyLineSealOverlayOff, false);
TriggerAddEventUnitBehaviorChange(libHMDV_gt_HeroMedivhLeyLineSealOverlayOff, null, "MedivhLeyLineSealStasis", c_unitBehaviorChangeDestroy);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Medivh - Portal Camera Pan
//--------------------------------------------------------------------------------------------------
bool libHMDV_gt_HeroMedivhPortalCameraPan_Func (bool testConds, bool runActions) {
// Variable Declarations
unit lv_teleportTarget;
// Automatic Variable Declarations
// Variable Initialization
lv_teleportTarget = EventPlayerEffectUsedUnit(c_effectUnitCaster);
// Actions
if (!runActions) {
return true;
}
libGame_gf_CameraPanCameraForPlayerAndUpdateMapBoundsIfNecessary(UnitGetOwner(lv_teleportTarget), UnitGetPosition(lv_teleportTarget), 0.0, -1, 0.0, true);
return true;
}
//--------------------------------------------------------------------------------------------------
void libHMDV_gt_HeroMedivhPortalCameraPan_Init () {
libHMDV_gt_HeroMedivhPortalCameraPan = TriggerCreate("libHMDV_gt_HeroMedivhPortalCameraPan_Func");
TriggerEnable(libHMDV_gt_HeroMedivhPortalCameraPan, false);
TriggerAddEventPlayerEffectUsed(libHMDV_gt_HeroMedivhPortalCameraPan, c_playerAny, "MedivhPortalTeleportToPortal");
}
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Medivh - Portal Portal Mastery Selection (Clamping)
//--------------------------------------------------------------------------------------------------
bool libHMDV_gt_HeroMedivhPortalPortalMasterySelectionClamping_Func (bool testConds, bool runActions) {
// Variable Declarations
unit lv_markerPortal;
unit lv_portalCaster;
// Automatic Variable Declarations
// Variable Initialization
// Actions
if (!runActions) {
return true;
}
lv_markerPortal = EventPlayerEffectUsedUnit(c_effectUnitTarget);
lv_portalCaster = EventPlayerEffectUsedUnit(c_effectUnitCaster);
UnitSelect(lv_markerPortal, UnitGetOwner(lv_portalCaster), true);
UISetSelectionTypeEnabled(PlayerGroupSingle(UnitGetOwner(lv_portalCaster)), c_localSelectionTypeWorldPanelHero, false);
while ((UnitIsAlive(lv_markerPortal) == true)) {
Wait(0.125, c_timeGame);
}
UISetSelectionTypeEnabled(PlayerGroupSingle(UnitGetOwner(lv_portalCaster)), c_localSelectionTypeWorldPanelHero, true);
return true;
}
//--------------------------------------------------------------------------------------------------
void libHMDV_gt_HeroMedivhPortalPortalMasterySelectionClamping_Init () {
libHMDV_gt_HeroMedivhPortalPortalMasterySelectionClamping = TriggerCreate("libHMDV_gt_HeroMedivhPortalPortalMasterySelectionClamping_Func");
TriggerEnable(libHMDV_gt_HeroMedivhPortalPortalMasterySelectionClamping, false);
TriggerAddEventPlayerEffectUsed(libHMDV_gt_HeroMedivhPortalPortalMasterySelectionClamping, c_playerAny, "MedivhPortalMarkerSpawnPersistent");
}
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Medivh - Portal Portal Mastery Morph Back To Medivh
//--------------------------------------------------------------------------------------------------
bool libHMDV_gt_HeroMedivhPortalPortalMasteryMorphBackToMedivh_Func (bool testConds, bool runActions) {
// Variable Declarations
int lv_portal2Owner;
unit lv_portal2Caster;
unit lv_medivh;
// Automatic Variable Declarations
// Variable Initialization
// Actions
if (!runActions) {
return true;
}
lv_portal2Caster = EventUnit();
lv_portal2Owner = UnitGetOwner(lv_portal2Caster);
lv_medivh = libGame_gv_players[lv_portal2Owner].lv_heroUnit;
UnitCreateEffectUnit(lv_medivh, "MedivhAbilityPrepareSet", lv_medivh);
UnitCreateEffectUnit(lv_medivh, "MedivhPortalCooldown", lv_medivh);
UnitCreateEffectUnit(lv_medivh, "MedivhPortalCreateCasterDurationPersistent", lv_medivh);
UnitBehaviorAdd(lv_medivh, "MedivhPortalPortalMasteryCastStun", lv_medivh, 1);
libNtve_gf_MakeUnitFacePoint(lv_medivh, EventUnitTargetPoint(), 0.0625);
if ((UnitOrderCount(lv_medivh) <= 1)) {
UnitIssueOrder(lv_medivh, Order(AbilityCommand("stop", 0)), c_orderQueueReplace);
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHMDV_gt_HeroMedivhPortalPortalMasteryMorphBackToMedivh_Init () {
libHMDV_gt_HeroMedivhPortalPortalMasteryMorphBackToMedivh = TriggerCreate("libHMDV_gt_HeroMedivhPortalPortalMasteryMorphBackToMedivh_Func");
TriggerEnable(libHMDV_gt_HeroMedivhPortalPortalMasteryMorphBackToMedivh, false);
TriggerAddEventUnitAbility(libHMDV_gt_HeroMedivhPortalPortalMasteryMorphBackToMedivh, null, AbilityCommand("MedivhPortal2", 0), c_abilEffectStageCast, false);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Medivh - Force of Will Behavior Responses
//--------------------------------------------------------------------------------------------------
bool libHMDV_gt_HeroMedivhForceofWillBehaviorResponses_Func (bool testConds, bool runActions) {
// Variable Declarations
int lv_medivhPlayer;
fixed lv_damageTaken;
unit lv_unit;
fixed lv_verticalOffset;
fixed lv_horizOffset;
unit lv_caster;
unit lv_shieldedUnit;
int lv_ownerofShieldedUnit;
fixed lv_healingModifier;
// Automatic Variable Declarations
// Variable Initialization
lv_damageTaken = EventUnitBehaviorCumulativeDamageModification();
lv_unit = EventUnit();
lv_verticalOffset = 2.0;
lv_horizOffset = RandomFixed(-0.4, -0.6);
lv_healingModifier = 0.2;
// Conditions
if (testConds) {
if (!((UnitGetOwner(lv_unit) <= libCore_gv_bALMaxPlayers))) {
return false;
}
if (!((UnitFilterMatch(lv_unit, UnitGetOwner(lv_unit), libCore_gv_filtersHeroic) == true))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
if ((EventUnitBehaviorChange() == c_unitBehaviorChangeIncrease)) {
lv_shieldedUnit = lv_unit;
lv_ownerofShieldedUnit = UnitGetOwner(lv_shieldedUnit);
lv_caster = UnitBehaviorEffectUnit(lv_shieldedUnit, EventUnitBehavior(), c_effectUnitCaster, 0);
libHMDV_gv_medivhForceofWillCaster[UnitGetOwner(lv_shieldedUnit)] = lv_caster;
libHMDV_gv_medivhForceofWillCasterOwner[UnitGetOwner(lv_shieldedUnit)] = UnitGetOwner(lv_caster);
PlayerGroupAdd(libHMDV_gv_medivhForceofWillPlayerGroup[lv_ownerofShieldedUnit], lv_ownerofShieldedUnit);
PlayerGroupAdd(libHMDV_gv_medivhForceofWillPlayerGroup[lv_ownerofShieldedUnit], UnitGetOwner(lv_caster));
}
else if ((EventUnitBehaviorChange() == c_unitBehaviorChangeDecrease)) {
lv_shieldedUnit = lv_unit;
lv_ownerofShieldedUnit = UnitGetOwner(lv_shieldedUnit);
lv_medivhPlayer = libHMDV_gv_medivhForceofWillCasterOwner[UnitGetOwner(lv_shieldedUnit)];
if ((lv_damageTaken > 0.0)) {
CatalogFieldValueSetFixed(c_gameCatalogEffect, "MedivhForceOfWillModifyTalentTokenCount", "Value", lv_ownerofShieldedUnit, lv_damageTaken);
UnitCreateEffectUnitWithSource(lv_shieldedUnit, "MedivhForceOfWillModifyTalentTokenCount", lv_shieldedUnit, c_gameCatalogAbil, "MedivhForceOfWill");
lv_verticalOffset = 1.0;
FloatingCombatElementCreateNumberTextAtUnit(libHMDV_gv_medivhForceofWillPlayerGroup[lv_ownerofShieldedUnit], "FloatingCombatElements/FloatingCombatAmountReadable", "", lv_shieldedUnit, FixedToInt(lv_damageTaken), StringExternal("Param/Value/lib_HMDV_C69061B6"), libNtve_gv_FloatingCombatTextAutoRandomSeed);
if ((PlayerHasTalent(lv_medivhPlayer, "MedivhForceOfWillReabsorption") == true)) {
CatalogFieldValueSetFixed(c_gameCatalogAccumulator, "MedivhForceOfWillHealingAccumulator", "Scale", lv_ownerofShieldedUnit, CatalogFieldValueGetAsFixed(c_gameCatalogAccumulator, "MedivhForceOfWillHealingDummyAccumulator", "Scale", lv_medivhPlayer));
}
else {
CatalogFieldValueSetFixed(c_gameCatalogAccumulator, "MedivhForceOfWillHealingAccumulator", "Scale", lv_ownerofShieldedUnit, CatalogFieldValueGetAsFixed(c_gameCatalogAccumulator, "MedivhForceOfWillHealingDummyAccumulator", "Scale", 0));
}
UnitCreateEffectUnitWithSource(libHMDV_gv_medivhForceofWillCaster[lv_ownerofShieldedUnit], "MedivhForceOfWillReabsorptionHeal", lv_shieldedUnit, c_gameCatalogAbil, "MedivhForceOfWill");
if ((PlayerHasTalent(lv_medivhPlayer, "MedivhForceOfWillEnduringWill") == true) && (lv_damageTaken >= CatalogFieldValueGetAsFixed(c_gameCatalogEffect, "MedivhForceOfWillEnduringWillTalentDummyTokenThreshold", "Value", lv_medivhPlayer))) {
UnitCreateEffectUnitWithSource(libGame_gv_players[lv_medivhPlayer].lv_heroUnit, "MedivhForceOfWillEnduringWillTalentModifyCooldown", libGame_gv_players[lv_medivhPlayer].lv_heroUnit, c_gameCatalogAbil, "MedivhForceOfWill");
}
if ((PlayerHasTalent(lv_medivhPlayer, "MedivhForceofMagic") == true) && (lv_damageTaken >= CatalogFieldValueGetAsFixed(c_gameCatalogEffect, "MedivhForceOfWillForceofMagicTalentDummyTokenThreshold", "Value", lv_medivhPlayer))) {
UnitCreateEffectUnitWithSource(libGame_gv_players[lv_medivhPlayer].lv_heroUnit, "MedivhForceOfWillApplyForceofMagicTalentStack", libGame_gv_players[lv_medivhPlayer].lv_heroUnit, c_gameCatalogAbil, "MedivhForceOfWill");
}
}
else if ((lv_damageTaken > 0.0)) {
FloatingCombatElementCreateNumberTextAtUnit(libHMDV_gv_medivhForceofWillPlayerGroup[lv_ownerofShieldedUnit], "FloatingCombatElements/FloatingCombatAmountReadable", "", lv_shieldedUnit, FixedToInt(lv_damageTaken), StringExternal("Param/Value/lib_HMDV_EB9E6C70"), libNtve_gv_FloatingCombatTextAutoRandomSeed);
}
if ((PlayerHasTalent(lv_medivhPlayer, "MedivhForceOfWillArcaneExplosion") == true)) {
CatalogFieldValueSetFixed(c_gameCatalogAccumulator, "MedivhArcaneExplosionDamageAccumulator", "MaxAccumulation", lv_ownerofShieldedUnit, CatalogFieldValueGetAsFixed(c_gameCatalogAccumulator, "MedivhArcaneExplosionDamageAccumulator", "MaxAccumulation", lv_medivhPlayer));
CatalogFieldValueSetFixed(c_gameCatalogEffect, "MedivhForceOfWillArcaneExplosionDamage", "Amount", lv_ownerofShieldedUnit, CatalogFieldValueGetAsFixed(c_gameCatalogEffect, "MedivhForceOfWillArcaneExplosionDamage", "Amount", lv_medivhPlayer));
UnitCreateEffectUnitWithSource(libGame_gv_players[lv_medivhPlayer].lv_heroUnit, "MedivhForceOfWillArcaneExplosionSearch", lv_shieldedUnit, c_gameCatalogAbil, "MedivhForceOfWill");
}
PlayerGroupClear(libHMDV_gv_medivhForceofWillPlayerGroup[lv_ownerofShieldedUnit]);
Wait(0.0625, c_timeGame);
UnitCreateEffectUnit(lv_shieldedUnit, "MedivhForceOfWillResetTalentTokenCount", lv_shieldedUnit);
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHMDV_gt_HeroMedivhForceofWillBehaviorResponses_Init () {
libHMDV_gt_HeroMedivhForceofWillBehaviorResponses = TriggerCreate("libHMDV_gt_HeroMedivhForceofWillBehaviorResponses_Func");
TriggerEnable(libHMDV_gt_HeroMedivhForceofWillBehaviorResponses, false);
TriggerAddEventUnitBehaviorChange(libHMDV_gt_HeroMedivhForceofWillBehaviorResponses, null, "MedivhForceOfWill", c_unitBehaviorChangeIncrease);
TriggerAddEventUnitBehaviorChange(libHMDV_gt_HeroMedivhForceofWillBehaviorResponses, null, "MedivhForceOfWill", c_unitBehaviorChangeDecrease);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Medivh - Force of Will - Remove Early
//--------------------------------------------------------------------------------------------------
bool libHMDV_gt_HeroMedivhForceofWillRemoveEarly_Func (bool testConds, bool runActions) {
// Automatic Variable Declarations
// Actions
if (!runActions) {
return true;
}
while ((UnitBehaviorDuration(EventUnit(), "MedivhForceOfWill") > 0.0625)) {
Wait(0.0625, c_timeGame);
}
UnitBehaviorRemove(EventUnit(), EventUnitBehavior(), 1);
return true;
}
//--------------------------------------------------------------------------------------------------
void libHMDV_gt_HeroMedivhForceofWillRemoveEarly_Init () {
libHMDV_gt_HeroMedivhForceofWillRemoveEarly = TriggerCreate("libHMDV_gt_HeroMedivhForceofWillRemoveEarly_Func");
TriggerEnable(libHMDV_gt_HeroMedivhForceofWillRemoveEarly, false);
TriggerAddEventUnitBehaviorChange(libHMDV_gt_HeroMedivhForceofWillRemoveEarly, null, "MedivhForceOfWill", c_unitBehaviorChangeCreate);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Medivh - Transform: Raven After Port To Town
//--------------------------------------------------------------------------------------------------
bool libHMDV_gt_HeroMedivhTransformRavenAfterPortToTown_Func (bool testConds, bool runActions) {
// Variable Declarations
int lv_player;
unit lv_medivhUnit;
// Automatic Variable Declarations
// Variable Initialization
lv_player = libGame_gf_HeroPortedBackToTownPlayer();
// Conditions
if (testConds) {
if (!((UnitGetType(libGame_gv_players[lv_player].lv_heroUnit) == "HeroMedivh"))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
lv_medivhUnit = libGame_gv_players[lv_player].lv_heroUnit;
UnitCreateEffectUnit(lv_medivhUnit, "MedivhTransformRavenFountainSet", lv_medivhUnit);
return true;
}
//--------------------------------------------------------------------------------------------------
void libHMDV_gt_HeroMedivhTransformRavenAfterPortToTown_Init () {
libHMDV_gt_HeroMedivhTransformRavenAfterPortToTown = TriggerCreate("libHMDV_gt_HeroMedivhTransformRavenAfterPortToTown_Func");
TriggerEnable(libHMDV_gt_HeroMedivhTransformRavenAfterPortToTown, false);
libGame_gf_HeroPortedBackToTown(libHMDV_gt_HeroMedivhTransformRavenAfterPortToTown);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Medivh - Transform: Raven Mounting Special Case
//--------------------------------------------------------------------------------------------------
bool libHMDV_gt_HeroMedivhTransformRavenMountingSpecialCase_Func (bool testConds, bool runActions) {
// Variable Declarations
int lv_player;
// Automatic Variable Declarations
// Variable Initialization
lv_player = libGame_gf_HeroSpecialCaseMountingPlayer();
// Conditions
if (testConds) {
if (!((UnitGetType(libGame_gv_players[lv_player].lv_heroUnit) == "HeroMedivh"))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
UnitCreateEffectUnit(libGame_gv_players[lv_player].lv_heroUnit, "MedivhTransformRavenFountainSet", libGame_gv_players[lv_player].lv_heroUnit);
return true;
}
//--------------------------------------------------------------------------------------------------
void libHMDV_gt_HeroMedivhTransformRavenMountingSpecialCase_Init () {
libHMDV_gt_HeroMedivhTransformRavenMountingSpecialCase = TriggerCreate("libHMDV_gt_HeroMedivhTransformRavenMountingSpecialCase_Func");
TriggerEnable(libHMDV_gt_HeroMedivhTransformRavenMountingSpecialCase, false);
libGame_gf_HeroSpecialCaseMounting(libHMDV_gt_HeroMedivhTransformRavenMountingSpecialCase);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Medivh - Transform: Swap To Medivh
//--------------------------------------------------------------------------------------------------
bool libHMDV_gt_HeroMedivhTransformSwapToMedivh_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()) <= 10))) {
return false;
}
if (!((UnitTestState(EventUnit(), c_unitStateHallucination) == false))) {
return false;
}
if (!((UnitIsAlive(EventUnit()) == true))) {
return false;
}
if (!((UnitBehaviorCount(EventUnit(), "MedivhForceOfWill") > 0))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
lv_player = UnitGetOwner(EventUnit());
lv_index = libUIUI_gf_UIUnitStatusFramesGetUnitIndex(lv_player, EventUnit());
Wait(0.0625, c_timeGame);
DialogControlSendAnimationEvent(libUIUI_gv_uIHeroStatusFrames[lv_player].lv_unitHealthBarInvincible[lv_index], PlayerGroupAll(), "InvincibleOn");
return true;
}
//--------------------------------------------------------------------------------------------------
void libHMDV_gt_HeroMedivhTransformSwapToMedivh_Init () {
libHMDV_gt_HeroMedivhTransformSwapToMedivh = TriggerCreate("libHMDV_gt_HeroMedivhTransformSwapToMedivh_Func");
TriggerEnable(libHMDV_gt_HeroMedivhTransformSwapToMedivh, false);
TriggerAddEventUnitBehaviorChange(libHMDV_gt_HeroMedivhTransformSwapToMedivh, null, "MedivhTransformRaven", c_unitBehaviorChangeDestroy);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Medivh - Portal Mastery CDR
//--------------------------------------------------------------------------------------------------
bool libHMDV_gt_HeroMedivhPortalMasteryCDR_Func (bool testConds, bool runActions) {
// Variable Declarations
string lv_triggeringEffect;
unit lv_target;
int lv_player;
// Automatic Variable Declarations
string auto3CF91448_val;
// Variable Initialization
lv_triggeringEffect = EventPlayerEffectUsed();
lv_target = EventPlayerEffectUsedUnit(c_effectUnitTarget);
lv_player = EventPlayerEffectUsedUnitOwner(c_effectPlayerTarget);
// Conditions
if (testConds) {
if (!((lv_player >= 1))) {
return false;
}
if (!((lv_player <= libCore_gv_bALMaxPlayers))) {
return false;
}
if (!(((UnitGetType(lv_target) == "HeroMedivh") || (UnitGetType(lv_target) == "HeroMedivhRaven")))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
auto3CF91448_val = lv_triggeringEffect;
if (auto3CF91448_val == "MalfurionInnervateModifyUnitDummy") {
UnitCreateEffectUnit(lv_target, "MedivhPortalMasteryInnervateModifyPlayer", lv_target);
}
else if (auto3CF91448_val == "AnaNanoBoostPeriodicDummyModifyUnit") {
UnitCreateEffectUnit(lv_target, "MedivhPortalMasteryNanoBoostModifyPlayer", lv_target);
}
else {
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHMDV_gt_HeroMedivhPortalMasteryCDR_Init () {
libHMDV_gt_HeroMedivhPortalMasteryCDR = TriggerCreate("libHMDV_gt_HeroMedivhPortalMasteryCDR_Func");
TriggerEnable(libHMDV_gt_HeroMedivhPortalMasteryCDR, false);
TriggerAddEventPlayerEffectUsed(libHMDV_gt_HeroMedivhPortalMasteryCDR, c_playerAny, "MalfurionInnervateModifyUnitDummy");
TriggerAddEventPlayerEffectUsed(libHMDV_gt_HeroMedivhPortalMasteryCDR, c_playerAny, "AnaNanoBoostPeriodicDummyModifyUnit");
}
void libHMDV_InitTriggers () {
libHMDV_gt_HeroMedivhRavenFamiliarSpawn_Init();
libHMDV_gt_HeroMedivhRavenFamiliarPostSpawnCloak_Init();
libHMDV_gt_HeroAIMedivhHasLanded_Init();
libHMDV_gt_HeroAIMedivhHasCastRavenForm_Init();
libHMDV_gt_HeroAIAIMedivhRegisterPortalCast_Init();
libHMDV_gt_HeroAIAIMedivhUnregisterPortal_Init();
libHMDV_gt_HeroMedivhLeyLineSealOverlayOn_Init();
libHMDV_gt_HeroMedivhLeyLineSealOverlayOff_Init();
libHMDV_gt_HeroMedivhPortalCameraPan_Init();
libHMDV_gt_HeroMedivhPortalPortalMasterySelectionClamping_Init();
libHMDV_gt_HeroMedivhPortalPortalMasteryMorphBackToMedivh_Init();
libHMDV_gt_HeroMedivhForceofWillBehaviorResponses_Init();
libHMDV_gt_HeroMedivhForceofWillRemoveEarly_Init();
libHMDV_gt_HeroMedivhTransformRavenAfterPortToTown_Init();
libHMDV_gt_HeroMedivhTransformRavenMountingSpecialCase_Init();
libHMDV_gt_HeroMedivhTransformSwapToMedivh_Init();
libHMDV_gt_HeroMedivhPortalMasteryCDR_Init();
}
//--------------------------------------------------------------------------------------------------
// Library Initialization
//--------------------------------------------------------------------------------------------------
bool libHMDV_InitLib_completed = false;
void libHMDV_InitLib () {
if (libHMDV_InitLib_completed) {
return;
}
libHMDV_InitLib_completed = true;
libHMDV_InitLibraries();
libHMDV_InitVariables();
libHMDV_InitTriggers();
}