include "TriggerLibs/NativeLib"
include "TriggerLibs/HeroesLib"
include "TriggerLibs/GameLib"
include "TriggerLibs/UILib"
include "TriggerLibs/SoundLib"
include "TriggerLibs/GameDataHelperLib"
include "LibHAUR_h"
//--------------------------------------------------------------------------------------------------
// Library: Auriel
//--------------------------------------------------------------------------------------------------
// External Library Initialization
void libHAUR_InitLibraries () {
libNtve_InitVariables();
libCore_InitVariables();
libGame_InitVariables();
libUIUI_InitVariables();
libSond_InitVariables();
libGDHL_InitVariables();
}
// Variable Initialization
bool libHAUR_InitVariables_completed = false;
void libHAUR_InitVariables () {
int init_i;
int init_j;
if (libHAUR_InitVariables_completed) {
return;
}
libHAUR_InitVariables_completed = true;
libHAUR_gv_aurielUI.lv_traitPanel = c_invalidDialogControlId;
libHAUR_gv_aurielUI.lv_traitLabel = c_invalidDialogControlId;
libHAUR_gv_aurielUI.lv_aurielBestowHopeTargetStatus = c_invalidDialogControlId;
libHAUR_gv_aurielUI.lv_aurielBestowHopeTargetDisplayName = c_invalidDialogControlId;
libHAUR_gv_aurielUI.lv_aurielBestowHopeTargetPortrait = c_invalidDialogControlId;
libHAUR_gv_aurielUI.lv_traitImageBar = c_invalidDialogControlId;
libHAUR_gv_aurielUI.lv_traitImageMaxBar = c_invalidDialogControlId;
libHAUR_gv_heroAurielBestowHopeNonHeroicDamageStoredFraction = 0.1;
libHAUR_gv_heroAurielBestowHopeHeroicDamageStoredFraction = 0.3;
for (init_i = 0; init_i <= libCore_gv_bALMaxPlayers; init_i += 1) {
for (init_j = 0; init_j <= 3; init_j += 1) {
libHAUR_gv_heroAurielResurrectDeadPlayerSpiritTimerTextTag[init_i][init_j] = c_textTagNone;
}
}
for (init_i = 0; init_i <= libCore_gv_bALMaxPlayers; init_i += 1) {
for (init_j = 0; init_j <= 3; init_j += 1) {
libHAUR_gv_heroAurielResurrectAurielSpiritTimerTextTag[init_i][init_j] = c_textTagNone;
}
}
for (init_i = 0; init_i <= libCore_gv_bALMaxPlayers; init_i += 1) {
libHAUR_gv_heroAurielResurrectRevivingNotification[init_i] = c_textTagNone;
}
for (init_i = 0; init_i <= libCore_gv_bALMaxPlayers; init_i += 1) {
libHAUR_gv_heroAurielResurrectCastingTimer[init_i] = TimerCreate();
}
for (init_i = 0; init_i <= libCore_gv_bALMaxPlayers; init_i += 1) {
libHAUR_gv_heroAurielResurrectRevivingDialog[init_i] = c_invalidDialogId;
}
for (init_i = 0; init_i <= libCore_gv_bALMaxPlayers; init_i += 1) {
libHAUR_gv_heroAurielResurrectFrameRecords[init_i].lv_heroAurielResurrectProgressTimer = TimerCreate();
}
for (init_i = 0; init_i <= libCore_gv_bALMaxPlayers; init_i += 1) {
libHAUR_gv_heroAurielResurrectNotifyTargetPlayerReviveInterruptedTimer[init_i] = TimerCreate();
}
}
// Functions
void libHAUR_gf_HeroAurielIncrementHeroCountFunction () {
// Automatic Variable Declarations
// Implementation
libHAUR_gv_heroAurielTriggerRegistrationVariable += 1;
if ((libHAUR_gv_heroAurielTriggerRegistrationVariable == 1)) {
TriggerEnable(libHAUR_gt_HeroAurielBestowHopeBestowHopeCast, true);
TriggerEnable(libHAUR_gt_HeroAurielBestowHopeSetProxy, true);
TriggerEnable(libHAUR_gt_HeroAurielBestowHopeRemoveProxy, true);
TriggerEnable(libHAUR_gt_HeroAurielBestowHopeToggleBestowHopeProxyDamageDealtTrigger, true);
TriggerEnable(libHAUR_gt_HeroAurielBestowHopeProxyUnitSwapped, true);
TriggerEnable(libHAUR_gt_HeroAurielCrystalAegisOverlayController, true);
TriggerEnable(libHAUR_gt_HeroAurielResurrectPlayerUnlocksResurrect, true);
TriggerEnable(libHAUR_gt_HeroAurielResurrectPlayerRespecs, true);
TriggerEnable(libHAUR_gt_HeroAurielResurrectPlayerRespawns, true);
TriggerEnable(libHAUR_gt_HeroAurielResurrectEndofGameHideRevivingDialog, true);
TriggerEnable(libHAUR_gt_HeroAurielResurrectLostVikingsPlayAgainStart, true);
libHAUR_gf_HeroAurielRayofHeavenPopulateValuesfromData();
}
}
void libHAUR_gf_HeroAurielDecrementHeroCountFunction () {
// Automatic Variable Declarations
// Implementation
libHAUR_gv_heroAurielTriggerRegistrationVariable -= 1;
if ((libHAUR_gv_heroAurielTriggerRegistrationVariable < 0)) {
libHAUR_gv_heroAurielTriggerRegistrationVariable = 0;
}
if ((libHAUR_gv_heroAurielTriggerRegistrationVariable == 0)) {
TriggerEnable(libHAUR_gt_HeroAurielBestowHopeBestowHopeCast, false);
TriggerEnable(libHAUR_gt_HeroAurielBestowHopeSetProxy, false);
TriggerEnable(libHAUR_gt_HeroAurielBestowHopeRemoveProxy, false);
TriggerEnable(libHAUR_gt_HeroAurielBestowHopeToggleBestowHopeProxyDamageDealtTrigger, false);
TriggerEnable(libHAUR_gt_HeroAurielBestowHopeHealingStoredFromProxyDamageDealt, false);
TriggerEnable(libHAUR_gt_HeroAurielBestowHopeHealingStoredFromProxyDamageTaken, false);
TriggerEnable(libHAUR_gt_HeroAurielBestowHopeProxyUnitSwapped, false);
TriggerEnable(libHAUR_gt_HeroAurielCrystalAegisOverlayController, false);
TriggerEnable(libHAUR_gt_HeroAurielResurrectPlayerUnlocksResurrect, false);
TriggerEnable(libHAUR_gt_HeroAurielResurrectCreateSpirit, false);
TriggerEnable(libHAUR_gt_HeroAurielResurrectMurkyEggDeathSpiritReveal, false);
TriggerEnable(libHAUR_gt_HeroAurielResurrectRevivePlayer, false);
TriggerEnable(libHAUR_gt_HeroAurielResurrectPlayerRespawns, false);
TriggerEnable(libHAUR_gt_HeroAurielResurrectLostVikingRespawns, false);
TriggerEnable(libHAUR_gt_HeroAurielResurrectLostVikingsPlayAgainComplete, false);
TriggerEnable(libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveStart, false);
TriggerEnable(libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveInterrupted, false);
TriggerEnable(libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveInterruptedTimerExpired, false);
TriggerEnable(libHAUR_gt_HeroAurielResurrectSpiritTimerController, false);
TriggerEnable(libHAUR_gt_HeroAurielResurrectPlayerRespecs, false);
TriggerEnable(libHAUR_gt_HeroAurielResurrectEndofGameHideRevivingDialog, false);
TriggerEnable(libHAUR_gt_HeroAurielResurrectLostVikingsPlayAgainStart, false);
}
}
string libHAUR_gf_BestowHopeGetPortraitPathforUnit (unit lp_unit) {
// Automatic Variable Declarations
string auto889C7C47_val;
// Implementation
auto889C7C47_val = UnitGetType(lp_unit);
if (auto889C7C47_val == "HeroChenStorm") {
return "Assets\\Textures\\storm_ui_ingame_targetinfopanel_unit_chen_storm.dds";
}
else if (auto889C7C47_val == "HeroChenEarth") {
return "Assets\\Textures\\storm_ui_ingame_targetinfopanel_unit_chen_earth.dds";
}
else if (auto889C7C47_val == "HeroChenFire") {
return "Assets\\Textures\\storm_ui_ingame_targetinfopanel_unit_chen_fire.dds";
}
else {
return libUIUI_gf_KillLogGetPortraitPathforUnit(lp_unit);
}
}
void libHAUR_gf_AurielUIBestowHope (int lp_aurielPlayer, unit lp_bestowHopeTarget) {
// Automatic Variable Declarations
// Implementation
libNtve_gf_SetDialogItemUnit(libHAUR_gv_aurielUI.lv_aurielBestowHopeTargetStatus, lp_bestowHopeTarget, libCore_gv_playerGroupFromPlayer[lp_aurielPlayer]);
DialogControlSetVisible(libHAUR_gv_aurielUI.lv_aurielBestowHopeTargetStatus, libCore_gv_playerGroupFromPlayer[lp_aurielPlayer], true);
libNtve_gf_SetDialogItemText(libHAUR_gv_aurielUI.lv_aurielBestowHopeTargetDisplayName, libHAUR_gf_AurielUIUnitDisplayName(lp_bestowHopeTarget), PlayerGroupSingle(lp_aurielPlayer));
libNtve_gf_SetDialogItemImage(libHAUR_gv_aurielUI.lv_aurielBestowHopeTargetPortrait, libHAUR_gf_BestowHopeGetPortraitPathforUnit(lp_bestowHopeTarget), PlayerGroupSingle(lp_aurielPlayer));
}
text libHAUR_gf_AurielUIUnitDisplayName (unit lp_unit) {
// Variable Declarations
int lv_unitOwner;
// Automatic Variable Declarations
// Variable Initialization
lv_unitOwner = UnitGetOwner(lp_unit);
// Implementation
if ((UnitGetType(lp_unit) == "HeroCho")) {
return StringExternal("Param/Value/lib_HAUR_1EB9CC4B");
}
else {
return UnitGetName(lp_unit);
}
}
void libHAUR_gf_HeroAurielRayofHeavenPopulateValuesfromData () {
// Automatic Variable Declarations
// Implementation
libHAUR_gv_heroAurielRayofHeavenHeroicDamageStoredFraction = StringToFixed(CatalogFieldValueGet(c_gameCatalogEffect, "AurielDamageVsHeroicTargetParent", "LeechFraction[" + IntToString(2) + "]", c_playerAny));
libHAUR_gv_heroAurielRayofHeavenNonHeroicDamageStoredFraction = StringToFixed(CatalogFieldValueGet(c_gameCatalogEffect, "AurielDamageVsNonHeroicTargetParent", "LeechFraction[" + IntToString(2) + "]", c_playerAny));
libHAUR_gv_heroAurielRayofHeavenReservoirofHopeHealingPerStack = StringToFixed(CatalogFieldValueGet(c_gameCatalogAccumulator, "AurielRayOfHeavenReservoirOfHopeAccumulator", "Scale", c_playerAny));
}
void libHAUR_gf_HeroAurielResurrectRevealSpirittoAurielandDeadPlayer (int lp_deadPlayer, unit lp_deadHero) {
// Variable Declarations
int lv_deadPlayerTeam;
int lv_aurielPlayer;
int lv_additionalPlayer;
// Automatic Variable Declarations
const int autoA5AA3F32_ae = libCore_gv_bALMaxPlayers;
const int autoA5AA3F32_ai = 1;
string autoEE4E787F_val;
// Variable Initialization
// Implementation
lv_deadPlayerTeam = libGame_gf_TeamNumberOfPlayer(lp_deadPlayer);
lv_aurielPlayer = 1;
for ( ; ( (autoA5AA3F32_ai >= 0 && lv_aurielPlayer <= autoA5AA3F32_ae) || (autoA5AA3F32_ai < 0 && lv_aurielPlayer >= autoA5AA3F32_ae) ) ; lv_aurielPlayer += autoA5AA3F32_ai ) {
if (((UnitGetType(libGame_gv_players[lv_aurielPlayer].lv_heroUnit) == "HeroAuriel") && (libGame_gf_TeamNumberOfPlayer(lv_aurielPlayer) == lv_deadPlayerTeam) && (UnitBehaviorCount(libGame_gv_players[lv_aurielPlayer].lv_heroUnit, "Ultimate1Unlocked") > 0) && (lv_aurielPlayer != lp_deadPlayer))) {
ActorSend(libNtve_gf_MainActorofUnit(libHAUR_gv_heroAurielResurrectSpirit[lp_deadPlayer]), libNtve_gf_Signal(("Auriel" + IntToString(lv_aurielPlayer))));
}
}
if ((UnitGetType(libGame_gv_players[lp_deadPlayer].lv_heroUnit) == "HeroCho")) {
lv_additionalPlayer = libGDHL_gv_chogallPairs[lv_deadPlayerTeam].lv_gallPlayer;
ActorSend(libNtve_gf_MainActorofUnit(libHAUR_gv_heroAurielResurrectSpirit[lp_deadPlayer]), libNtve_gf_Signal(("Auriel" + IntToString(lv_additionalPlayer))));
libHAUR_gv_heroAurielResurrectShowSpiritTimer[lv_additionalPlayer] = true;
}
ActorSend(libNtve_gf_MainActorofUnit(libHAUR_gv_heroAurielResurrectSpirit[lp_deadPlayer]), libNtve_gf_Signal(("Auriel" + IntToString(lp_deadPlayer))));
autoEE4E787F_val = UnitGetType(lp_deadHero);
if (autoEE4E787F_val == "HeroAlexstraszaDragon") {
ActorSend(libNtve_gf_MainActorofUnit(libHAUR_gv_heroAurielResurrectSpirit[lp_deadPlayer]), libNtve_gf_ModelSwap(libCore_gf_GetModelLinkForUnitType("HeroAlexstrasza"), 0));
}
else {
ActorSend(libNtve_gf_MainActorofUnit(libHAUR_gv_heroAurielResurrectSpirit[lp_deadPlayer]), libNtve_gf_ModelSwap(libCore_gf_GetModelLinkForUnitType(UnitGetType(lp_deadHero)), 0));
}
ActorSend(libNtve_gf_MainActorofUnit(libHAUR_gv_heroAurielResurrectSpirit[lp_deadPlayer]), libNtve_gf_Signal("Taunt"));
libHAUR_gv_heroAurielResurrectShowSpiritTimer[lp_deadPlayer] = true;
}
void libHAUR_gf_HeroAurielResurrectCheckActiveSpirits (bool lp_targetHeroDead) {
// Automatic Variable Declarations
// Implementation
if ((lp_targetHeroDead == true)) {
libHAUR_gv_heroAurielResurrectActiveSpirits += 1;
}
else {
libHAUR_gv_heroAurielResurrectActiveSpirits -= 1;
}
if ((libHAUR_gv_heroAurielResurrectActiveSpirits < 0)) {
libHAUR_gv_heroAurielResurrectActiveSpirits = 0;
}
if ((libHAUR_gv_heroAurielResurrectActiveSpirits == 0)) {
TriggerEnable(libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveStart, false);
TriggerEnable(libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveInterrupted, false);
TriggerEnable(libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveInterruptedTimerExpired, false);
TriggerEnable(libHAUR_gt_HeroAurielResurrectSpiritTimerController, false);
TriggerEnable(libHAUR_gt_HeroAurielResurrectLostVikingRespawns, false);
TriggerEnable(libHAUR_gt_HeroAurielResurrectLostVikingsPlayAgainComplete, false);
TriggerEnable(libHAUR_gt_HeroAurielResurrectLeoricSpiritFollow, false);
TriggerEnable(libHAUR_gt_HeroAurielResurrectMurkyEggDeathSpiritReveal, false);
}
else {
TriggerEnable(libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveStart, true);
TriggerEnable(libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveInterruptedTimerExpired, true);
TriggerEnable(libHAUR_gt_HeroAurielResurrectSpiritTimerController, true);
}
}
int libHAUR_gf_HeroAurielResurrectCreateDeadPlayerSpiritTimer (int lp_aurielPlayer, int lp_deadPlayer, int lp_vikingNumber) {
// Automatic Variable Declarations
// Implementation
if ((UnitIsAlive(libGame_gv_players[lp_aurielPlayer].lv_heroUnit) == true)) {
if ((UnitGetType(libGame_gv_players[lp_deadPlayer].lv_heroUnit) != "HeroLostVikingsController")) {
if ((libCore_gf_IsAbilityOnCooldown(libGame_gv_players[lp_aurielPlayer].lv_heroUnit, "AurielResurrect") == true)) {
TextExpressionSetToken("Param/Expression/lib_HAUR_8881BDD0", "A", FixedToText(UnitGetCooldown(libGame_gv_players[lp_aurielPlayer].lv_heroUnit, CatalogFieldValueGet(c_gameCatalogAbil, "AurielResurrect", "Cost[" + IntToString(0) + "].Cooldown.Link", lp_aurielPlayer)), 0));
TextExpressionSetToken("Param/Expression/lib_HAUR_8881BDD0", "B", FixedToText(TimerGetRemaining(libGame_gv_players[lp_deadPlayer].lv_respawnTimer), 0));
TextTagCreate(TextExpressionAssemble("Param/Expression/lib_HAUR_8881BDD0"), 36, UnitGetPosition(libHAUR_gv_heroAurielResurrectSpirit[lp_deadPlayer]), 4.0, true, false, PlayerGroupSingle(lp_deadPlayer));
return TextTagLastCreated();
}
else {
TextTagCreate((StringExternal("Param/Value/lib_HAUR_9C54CB75") + FixedToText(TimerGetRemaining(libGame_gv_players[lp_deadPlayer].lv_respawnTimer), 0)), 36, UnitGetPosition(libHAUR_gv_heroAurielResurrectSpirit[lp_deadPlayer]), 4.0, true, false, PlayerGroupSingle(lp_deadPlayer));
return TextTagLastCreated();
}
}
else {
if ((lp_vikingNumber == 1)) {
if ((libCore_gf_IsAbilityOnCooldown(libGame_gv_players[lp_aurielPlayer].lv_heroUnit, "AurielResurrect") == true)) {
TextExpressionSetToken("Param/Expression/lib_HAUR_52754345", "A", FixedToText(UnitGetCooldown(libGame_gv_players[lp_aurielPlayer].lv_heroUnit, CatalogFieldValueGet(c_gameCatalogAbil, "AurielResurrect", "Cost[" + IntToString(0) + "].Cooldown.Link", lp_aurielPlayer)), 0));
TextExpressionSetToken("Param/Expression/lib_HAUR_52754345", "B", FixedToText(TimerGetRemaining(libGDHL_gv_lostVikingsPlayer[lp_deadPlayer].lv_baleogDeathTimer), 0));
TextTagCreate(TextExpressionAssemble("Param/Expression/lib_HAUR_52754345"), 36, UnitGetPosition(libHAUR_gv_heroAurielResurrectSpirit[lp_deadPlayer]), 4.0, true, false, PlayerGroupSingle(lp_deadPlayer));
return TextTagLastCreated();
}
else {
TextTagCreate((StringExternal("Param/Value/lib_HAUR_8F9E5B15") + FixedToText(TimerGetRemaining(libGDHL_gv_lostVikingsPlayer[lp_deadPlayer].lv_baleogDeathTimer), 0)), 36, UnitGetPosition(libHAUR_gv_heroAurielResurrectSpirit[lp_deadPlayer]), 4.0, true, false, PlayerGroupSingle(lp_deadPlayer));
return TextTagLastCreated();
}
}
else {
if ((lp_vikingNumber == 2)) {
if ((libCore_gf_IsAbilityOnCooldown(libGame_gv_players[lp_aurielPlayer].lv_heroUnit, "AurielResurrect") == true)) {
TextExpressionSetToken("Param/Expression/lib_HAUR_2C638B40", "A", FixedToText(UnitGetCooldown(libGame_gv_players[lp_aurielPlayer].lv_heroUnit, CatalogFieldValueGet(c_gameCatalogAbil, "AurielResurrect", "Cost[" + IntToString(0) + "].Cooldown.Link", lp_aurielPlayer)), 0));
TextExpressionSetToken("Param/Expression/lib_HAUR_2C638B40", "B", FixedToText(TimerGetRemaining(libGDHL_gv_lostVikingsPlayer[lp_deadPlayer].lv_erikDeathTimer), 0));
TextTagCreate(TextExpressionAssemble("Param/Expression/lib_HAUR_2C638B40"), 36, UnitGetPosition(libHAUR_gv_heroAurielResurrectSpirit[lp_deadPlayer]), 4.0, true, false, PlayerGroupSingle(lp_deadPlayer));
return TextTagLastCreated();
}
else {
TextTagCreate((StringExternal("Param/Value/lib_HAUR_F323B22D") + FixedToText(TimerGetRemaining(libGDHL_gv_lostVikingsPlayer[lp_deadPlayer].lv_erikDeathTimer), 0)), 36, UnitGetPosition(libHAUR_gv_heroAurielResurrectSpirit[lp_deadPlayer]), 4.0, true, false, PlayerGroupSingle(lp_deadPlayer));
return TextTagLastCreated();
}
}
else {
if ((lp_vikingNumber == 3)) {
if ((libCore_gf_IsAbilityOnCooldown(libGame_gv_players[lp_aurielPlayer].lv_heroUnit, "AurielResurrect") == true)) {
TextExpressionSetToken("Param/Expression/lib_HAUR_33DF3109", "A", FixedToText(UnitGetCooldown(libGame_gv_players[lp_aurielPlayer].lv_heroUnit, CatalogFieldValueGet(c_gameCatalogAbil, "AurielResurrect", "Cost[" + IntToString(0) + "].Cooldown.Link", lp_aurielPlayer)), 0));
TextExpressionSetToken("Param/Expression/lib_HAUR_33DF3109", "B", FixedToText(TimerGetRemaining(libGDHL_gv_lostVikingsPlayer[lp_deadPlayer].lv_olafDeathTimer), 0));
TextTagCreate(TextExpressionAssemble("Param/Expression/lib_HAUR_33DF3109"), 36, UnitGetPosition(libHAUR_gv_heroAurielResurrectSpirit[lp_deadPlayer]), 4.0, true, false, PlayerGroupSingle(lp_deadPlayer));
return TextTagLastCreated();
}
else {
TextTagCreate((StringExternal("Param/Value/lib_HAUR_AC15E6DE") + FixedToText(TimerGetRemaining(libGDHL_gv_lostVikingsPlayer[lp_deadPlayer].lv_olafDeathTimer), 0)), 36, UnitGetPosition(libHAUR_gv_heroAurielResurrectSpirit[lp_deadPlayer]), 4.0, true, false, PlayerGroupSingle(lp_deadPlayer));
return TextTagLastCreated();
}
}
else {
return c_textTagNone;
}
}
}
}
}
else {
return c_textTagNone;
}
}
// Triggers
//--------------------------------------------------------------------------------------------------
// Trigger: Auriel UI Initialize
//--------------------------------------------------------------------------------------------------
bool libHAUR_gt_AurielUIInitialize_Func (bool testConds, bool runActions) {
int init_i;
// Variable Declarations
int[6] lv_panels;
int lv_currentPanelLayer;
// Automatic Variable Declarations
// Variable Initialization
for (init_i = 0; init_i <= 5; init_i += 1) {
lv_panels[init_i] = c_invalidDialogControlId;
}
// Actions
if (!runActions) {
return true;
}
DialogControlHookup(libUIUI_gv_heroSpecificStatusContainer, c_triggerControlTypeImage, "AurielBestowHopeFrame/TargetStatus/HeroPortraitContainer/HeroPortrait");
libHAUR_gv_aurielUI.lv_aurielBestowHopeTargetPortrait = DialogControlLastCreated();
DialogControlHookup(libUIUI_gv_heroSpecificStatusContainer, c_triggerControlTypeLabel, "AurielBestowHopeFrame/TargetStatus/UnitDisplayName");
libHAUR_gv_aurielUI.lv_aurielBestowHopeTargetDisplayName = DialogControlLastCreated();
DialogControlHookup(libUIUI_gv_heroSpecificStatusContainer, c_triggerControlTypeUnitStatus, "AurielBestowHopeFrame/TargetStatus");
libHAUR_gv_aurielUI.lv_aurielBestowHopeTargetStatus = DialogControlLastCreated();
lv_currentPanelLayer += 1;
lv_panels[lv_currentPanelLayer] = DialogControlLastCreated();
return true;
}
//--------------------------------------------------------------------------------------------------
void libHAUR_gt_AurielUIInitialize_Init () {
libHAUR_gt_AurielUIInitialize = TriggerCreate("libHAUR_gt_AurielUIInitialize_Func");
libCore_gf_IncludeModInitialization(libHAUR_gt_AurielUIInitialize);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Auriel - Shield of Hope - Set Shield Strength
//--------------------------------------------------------------------------------------------------
bool libHAUR_gt_HeroAurielShieldofHopeSetShieldStrength_Func (bool testConds, bool runActions) {
// Variable Declarations
unit lv_caster;
int lv_casterPlayer;
unit lv_target;
fixed lv_targetMissingHealth;
const fixed lv_shieldFraction = 0.5;
fixed lv_shieldValue;
// Automatic Variable Declarations
// Variable Initialization
lv_caster = EventPlayerEffectUsedUnit(c_effectUnitCaster);
lv_casterPlayer = UnitGetOwner(lv_caster);
lv_target = EventPlayerEffectUsedUnit(c_effectUnitTarget);
lv_targetMissingHealth = (UnitGetPropertyFixed(lv_target, c_unitPropLifeMax, c_unitPropCurrent) - UnitGetPropertyFixed(lv_target, c_unitPropLife, c_unitPropCurrent));
lv_shieldValue = (lv_targetMissingHealth * lv_shieldFraction);
// Conditions
if (testConds) {
if (!((lv_targetMissingHealth > 0.0))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
CatalogFieldValueSetFixed(c_gameCatalogBehavior, "AurielShieldOfHopeShieldBehavior", "DamageResponse.ModifyLimit", lv_casterPlayer, lv_shieldValue);
UnitCreateEffectUnit(lv_caster, "AurielShieldOfHopeApplyShieldBehavior", lv_target);
return true;
}
//--------------------------------------------------------------------------------------------------
void libHAUR_gt_HeroAurielShieldofHopeSetShieldStrength_Init () {
libHAUR_gt_HeroAurielShieldofHopeSetShieldStrength = TriggerCreate("libHAUR_gt_HeroAurielShieldofHopeSetShieldStrength_Func");
TriggerEnable(libHAUR_gt_HeroAurielShieldofHopeSetShieldStrength, false);
TriggerAddEventPlayerEffectUsed(libHAUR_gt_HeroAurielShieldofHopeSetShieldStrength, c_playerAny, "AurielShieldOfHopeImpactSet");
}
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Auriel - Bestow Hope - Bestow Hope Cast
//--------------------------------------------------------------------------------------------------
bool libHAUR_gt_HeroAurielBestowHopeBestowHopeCast_Func (bool testConds, bool runActions) {
// Variable Declarations
unit lv_auriel;
int lv_aurielPlayer;
int lv_proxyOwner;
unit lv_proxy;
int lv_iPlayer;
unit lv_previousProxy;
// Automatic Variable Declarations
// Variable Initialization
lv_iPlayer = 1;
// Conditions
if (testConds) {
if (!((UnitIsValid(EventPlayerEffectUsedUnit(c_effectUnitTarget)) == true))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
lv_auriel = EventPlayerEffectUsedUnit(c_effectUnitCaster);
lv_aurielPlayer = UnitGetOwner(lv_auriel);
lv_proxy = EventPlayerEffectUsedUnit(c_effectUnitTarget);
lv_proxyOwner = UnitGetOwner(lv_proxy);
lv_previousProxy = libHAUR_gv_heroAurielBestowHopeProxy[lv_aurielPlayer];
if ((UnitIsValid(lv_previousProxy) == true)) {
UnitCreateEffectUnit(lv_auriel, "AurielBestowHopeRemovalSet", lv_previousProxy);
lv_previousProxy = null;
Wait(0.125, c_timeGame);
}
if ((UnitIsValid(lv_auriel) == true) && (UnitIsValid(lv_proxy) == true)) {
UnitCreateEffectUnit(lv_auriel, "AurielBestowHopeApplicationSet", lv_proxy);
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHAUR_gt_HeroAurielBestowHopeBestowHopeCast_Init () {
libHAUR_gt_HeroAurielBestowHopeBestowHopeCast = TriggerCreate("libHAUR_gt_HeroAurielBestowHopeBestowHopeCast_Func");
TriggerEnable(libHAUR_gt_HeroAurielBestowHopeBestowHopeCast, false);
TriggerAddEventPlayerEffectUsed(libHAUR_gt_HeroAurielBestowHopeBestowHopeCast, c_playerAny, "AurielBestowHopeInitialSet");
}
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Auriel - Bestow Hope - Set Proxy
//--------------------------------------------------------------------------------------------------
bool libHAUR_gt_HeroAurielBestowHopeSetProxy_Func (bool testConds, bool runActions) {
// Variable Declarations
unit lv_auriel;
int lv_aurielPlayer;
unit lv_proxy;
int lv_proxyOwner;
int lv_iPlayer;
// Automatic Variable Declarations
// Variable Initialization
lv_proxy = EventPlayerEffectUsedUnit(c_effectUnitTarget);
lv_proxyOwner = UnitGetOwner(lv_proxy);
lv_iPlayer = 1;
// Actions
if (!runActions) {
return true;
}
lv_auriel = EventPlayerEffectUsedUnit(c_effectUnitCaster);
lv_aurielPlayer = UnitGetOwner(lv_auriel);
if ((UnitIsValid(lv_auriel) == true) && (UnitIsValid(lv_proxy) == true) && (lv_aurielPlayer <= libCore_gv_bALMaxEnginePlayerCount) && (lv_proxyOwner <= libCore_gv_bALMaxEnginePlayerCount)) {
libHAUR_gv_heroAurielBestowHopeProxy[lv_aurielPlayer] = lv_proxy;
libHAUR_gv_heroAurielBestowHopeProxyOwner[lv_proxyOwner] = lv_aurielPlayer;
libHAUR_gv_heroAurielBestowHopeNumberofActiveProxies += 1;
libHAUR_gf_AurielUIBestowHope(lv_aurielPlayer, lv_proxy);
if (((UnitGetType(lv_proxy) == "HeroCho") && (UnitHasBehavior2(lv_proxy, "AbathurUltimateEvolutionControlBehavior") == false))) {
UnitCreateEffectUnit(lv_auriel, "AurielBestowHopeApplyProxyBehavior", libGDHL_gv_chogallPairs[libGame_gf_TeamNumberOfPlayer(lv_proxyOwner)].lv_gallUnit);
}
}
TriggerExecute(libHAUR_gt_HeroAurielBestowHopeToggleBestowHopeProxyDamageDealtTrigger, true, false);
return true;
}
//--------------------------------------------------------------------------------------------------
void libHAUR_gt_HeroAurielBestowHopeSetProxy_Init () {
libHAUR_gt_HeroAurielBestowHopeSetProxy = TriggerCreate("libHAUR_gt_HeroAurielBestowHopeSetProxy_Func");
TriggerEnable(libHAUR_gt_HeroAurielBestowHopeSetProxy, false);
TriggerAddEventPlayerEffectUsed(libHAUR_gt_HeroAurielBestowHopeSetProxy, c_playerAny, "AurielBestowHopeApplyCasterBehavior");
}
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Auriel - Bestow Hope - Remove Proxy
//--------------------------------------------------------------------------------------------------
bool libHAUR_gt_HeroAurielBestowHopeRemoveProxy_Func (bool testConds, bool runActions) {
// Variable Declarations
int lv_iPlayer;
// Automatic Variable Declarations
// Variable Initialization
lv_iPlayer = 1;
// Conditions
if (testConds) {
if (!((UnitGetType(EventUnit()) != "HeroGall"))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
libHAUR_gv_heroAurielBestowHopeNumberofActiveProxies -= 1;
TriggerExecute(libHAUR_gt_HeroAurielBestowHopeToggleBestowHopeProxyDamageDealtTrigger, true, false);
return true;
}
//--------------------------------------------------------------------------------------------------
void libHAUR_gt_HeroAurielBestowHopeRemoveProxy_Init () {
libHAUR_gt_HeroAurielBestowHopeRemoveProxy = TriggerCreate("libHAUR_gt_HeroAurielBestowHopeRemoveProxy_Func");
TriggerEnable(libHAUR_gt_HeroAurielBestowHopeRemoveProxy, false);
TriggerAddEventUnitBehaviorChange(libHAUR_gt_HeroAurielBestowHopeRemoveProxy, null, "AurielBestowHopeProxyBehavior", c_unitBehaviorChangeDecrease);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Auriel - Bestow Hope - Toggle Bestow Hope Proxy Damage Dealt Trigger
//--------------------------------------------------------------------------------------------------
bool libHAUR_gt_HeroAurielBestowHopeToggleBestowHopeProxyDamageDealtTrigger_Func (bool testConds, bool runActions) {
// Automatic Variable Declarations
// Actions
if (!runActions) {
return true;
}
if ((libHAUR_gv_heroAurielBestowHopeNumberofActiveProxies > 0)) {
TriggerEnable(libHAUR_gt_HeroAurielBestowHopeHealingStoredFromProxyDamageDealt, true);
TriggerEnable(libHAUR_gt_HeroAurielBestowHopeHealingStoredFromProxyDamageTaken, true);
}
else {
TriggerEnable(libHAUR_gt_HeroAurielBestowHopeHealingStoredFromProxyDamageDealt, false);
TriggerEnable(libHAUR_gt_HeroAurielBestowHopeHealingStoredFromProxyDamageTaken, false);
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHAUR_gt_HeroAurielBestowHopeToggleBestowHopeProxyDamageDealtTrigger_Init () {
libHAUR_gt_HeroAurielBestowHopeToggleBestowHopeProxyDamageDealtTrigger = TriggerCreate("libHAUR_gt_HeroAurielBestowHopeToggleBestowHopeProxyDamageDealtTrigger_Func");
TriggerEnable(libHAUR_gt_HeroAurielBestowHopeToggleBestowHopeProxyDamageDealtTrigger, false);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Auriel - Bestow Hope - Healing Stored From Proxy Damage Dealt
//--------------------------------------------------------------------------------------------------
bool libHAUR_gt_HeroAurielBestowHopeHealingStoredFromProxyDamageDealt_Func (bool testConds, bool runActions) {
// Variable Declarations
fixed lv_damageDealt;
unit lv_auriel;
unit lv_proxy;
int lv_proxyPlayer;
int lv_aurielPlayer;
unit lv_target;
int lv_bestowHopeStacks;
int lv_bestowHopeStackIteration;
// Automatic Variable Declarations
int auto1108B650_ae;
const int auto1108B650_ai = 1;
// Variable Initialization
lv_damageDealt = (EventUnitDamageAmount() + EventUnitDamageBehaviorShield());
lv_proxy = EventUnitDamageSourceUnit();
lv_proxyPlayer = UnitGetOwner(lv_proxy);
lv_target = EventUnit();
// Conditions
if (testConds) {
if (!((lv_target != lv_proxy))) {
return false;
}
if (!((UnitGetOwner(lv_target) != UnitGetOwner(lv_proxy)))) {
return false;
}
if (!((UnitIsValid(lv_proxy) == true))) {
return false;
}
if (!((UnitIsValid(lv_target) == true))) {
return false;
}
if (!(((UnitHasBehavior2(lv_proxy, "AurielBestowHopeProxyBehavior") == true) || (UnitHasBehavior2(libGame_gv_players[lv_proxyPlayer].lv_heroUnit, "AurielBestowHopeProxyBehavior") == true)))) {
return false;
}
if (!((EventUnitDamageEffect() != "BribeKillEffect"))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
if ((UnitHasBehavior2(lv_proxy, "AurielBestowHopeProxyBehavior") == false) && (UnitHasBehavior2(libGame_gv_players[lv_proxyPlayer].lv_heroUnit, "AurielBestowHopeProxyBehavior") == true)) {
lv_proxy = libGame_gv_players[lv_proxyPlayer].lv_heroUnit;
}
lv_bestowHopeStacks = UnitBehaviorCount(lv_proxy, "AurielBestowHopeProxyBehavior");
auto1108B650_ae = lv_bestowHopeStacks;
lv_bestowHopeStackIteration = 0;
for ( ; ( (auto1108B650_ai >= 0 && lv_bestowHopeStackIteration <= auto1108B650_ae) || (auto1108B650_ai < 0 && lv_bestowHopeStackIteration >= auto1108B650_ae) ) ; lv_bestowHopeStackIteration += auto1108B650_ai ) {
lv_auriel = UnitBehaviorEffectUnit(lv_proxy, "AurielBestowHopeProxyBehavior", c_effectUnitCaster, lv_bestowHopeStackIteration);
lv_aurielPlayer = UnitGetOwner(lv_auriel);
if ((UnitTypeTestAttribute(UnitGetType(lv_target), c_unitAttributeHeroic) == true)) {
CatalogFieldValueSetFixed(c_gameCatalogEffect, "AurielBestowHopeRestoreHope", "RechargeVitalRate", lv_proxyPlayer, (lv_damageDealt * libHAUR_gv_heroAurielBestowHopeHeroicDamageStoredFraction));
UnitCreateEffectUnit(lv_proxy, "AurielBestowHopeRestoreHopeSet", lv_auriel);
}
else {
CatalogFieldValueSetFixed(c_gameCatalogEffect, "AurielBestowHopeRestoreHope", "RechargeVitalRate", lv_proxyPlayer, (lv_damageDealt * libHAUR_gv_heroAurielBestowHopeNonHeroicDamageStoredFraction));
UnitCreateEffectUnit(lv_proxy, "AurielBestowHopeRestoreHopeSet", lv_auriel);
}
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHAUR_gt_HeroAurielBestowHopeHealingStoredFromProxyDamageDealt_Init () {
libHAUR_gt_HeroAurielBestowHopeHealingStoredFromProxyDamageDealt = TriggerCreate("libHAUR_gt_HeroAurielBestowHopeHealingStoredFromProxyDamageDealt_Func");
TriggerEnable(libHAUR_gt_HeroAurielBestowHopeHealingStoredFromProxyDamageDealt, false);
TriggerAddEventUnitDamaged(libHAUR_gt_HeroAurielBestowHopeHealingStoredFromProxyDamageDealt, null, c_unitDamageTypeAny, c_unitDamageEither, null);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Auriel - Bestow Hope - Healing Stored From Proxy Damage Taken
//--------------------------------------------------------------------------------------------------
bool libHAUR_gt_HeroAurielBestowHopeHealingStoredFromProxyDamageTaken_Func (bool testConds, bool runActions) {
// Variable Declarations
fixed lv_damageTaken;
unit lv_aurielProxy;
unit lv_auriel;
int lv_proxyPlayer;
int lv_damagingPlayer;
// Automatic Variable Declarations
// Variable Initialization
lv_aurielProxy = EventUnit();
lv_proxyPlayer = UnitGetOwner(lv_aurielProxy);
lv_damagingPlayer = UnitGetOwner(EventUnitDamageSourceUnit());
// Conditions
if (testConds) {
if (!((UnitBehaviorCount(lv_aurielProxy, "AurielBestowHopeProxyBehavior") > 0))) {
return false;
}
if (!((lv_proxyPlayer != lv_damagingPlayer))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
if ((PlayerHasTalent(libHAUR_gv_heroAurielBestowHopeProxyOwner[lv_proxyPlayer], "AurielEmpathicLinkBestowHopeTalent") == true)) {
lv_auriel = libGame_gv_players[libHAUR_gv_heroAurielBestowHopeProxyOwner[lv_proxyPlayer]].lv_heroUnit;
lv_damageTaken = (EventUnitDamageAmount() + EventUnitDamageBehaviorShield());
CatalogFieldValueSetFixed(c_gameCatalogEffect, "AurielBestowHopeEmpathicLinkRestoreHope", "RechargeVitalRate", lv_proxyPlayer, (lv_damageTaken * libHAUR_gv_heroAurielBestowHopeEmpathicLinkStoredPercentage));
UnitCreateEffectUnit(lv_aurielProxy, "AurielBestowHopeRestoreHopeEmpathicLinkSet", lv_auriel);
}
if ((UnitIsAlive(EventUnit()) == false)) {
UnitBehaviorRemove(EventUnit(), "AurielBestowHopeProxyBehavior", 1);
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHAUR_gt_HeroAurielBestowHopeHealingStoredFromProxyDamageTaken_Init () {
libHAUR_gt_HeroAurielBestowHopeHealingStoredFromProxyDamageTaken = TriggerCreate("libHAUR_gt_HeroAurielBestowHopeHealingStoredFromProxyDamageTaken_Func");
TriggerEnable(libHAUR_gt_HeroAurielBestowHopeHealingStoredFromProxyDamageTaken, false);
TriggerAddEventUnitDamaged(libHAUR_gt_HeroAurielBestowHopeHealingStoredFromProxyDamageTaken, UnitRefFromVariable("libHAUR_gv_heroAurielBestowHopeProxy[1]"), c_unitDamageTypeAny, c_unitDamageEither, null);
TriggerAddEventUnitDamaged(libHAUR_gt_HeroAurielBestowHopeHealingStoredFromProxyDamageTaken, UnitRefFromVariable("libHAUR_gv_heroAurielBestowHopeProxy[2]"), c_unitDamageTypeAny, c_unitDamageEither, null);
TriggerAddEventUnitDamaged(libHAUR_gt_HeroAurielBestowHopeHealingStoredFromProxyDamageTaken, UnitRefFromVariable("libHAUR_gv_heroAurielBestowHopeProxy[3]"), c_unitDamageTypeAny, c_unitDamageEither, null);
TriggerAddEventUnitDamaged(libHAUR_gt_HeroAurielBestowHopeHealingStoredFromProxyDamageTaken, UnitRefFromVariable("libHAUR_gv_heroAurielBestowHopeProxy[4]"), c_unitDamageTypeAny, c_unitDamageEither, null);
TriggerAddEventUnitDamaged(libHAUR_gt_HeroAurielBestowHopeHealingStoredFromProxyDamageTaken, UnitRefFromVariable("libHAUR_gv_heroAurielBestowHopeProxy[5]"), c_unitDamageTypeAny, c_unitDamageEither, null);
TriggerAddEventUnitDamaged(libHAUR_gt_HeroAurielBestowHopeHealingStoredFromProxyDamageTaken, UnitRefFromVariable("libHAUR_gv_heroAurielBestowHopeProxy[6]"), c_unitDamageTypeAny, c_unitDamageEither, null);
TriggerAddEventUnitDamaged(libHAUR_gt_HeroAurielBestowHopeHealingStoredFromProxyDamageTaken, UnitRefFromVariable("libHAUR_gv_heroAurielBestowHopeProxy[7]"), c_unitDamageTypeAny, c_unitDamageEither, null);
TriggerAddEventUnitDamaged(libHAUR_gt_HeroAurielBestowHopeHealingStoredFromProxyDamageTaken, UnitRefFromVariable("libHAUR_gv_heroAurielBestowHopeProxy[8]"), c_unitDamageTypeAny, c_unitDamageEither, null);
TriggerAddEventUnitDamaged(libHAUR_gt_HeroAurielBestowHopeHealingStoredFromProxyDamageTaken, UnitRefFromVariable("libHAUR_gv_heroAurielBestowHopeProxy[9]"), c_unitDamageTypeAny, c_unitDamageEither, null);
TriggerAddEventUnitDamaged(libHAUR_gt_HeroAurielBestowHopeHealingStoredFromProxyDamageTaken, UnitRefFromVariable("libHAUR_gv_heroAurielBestowHopeProxy[10]"), c_unitDamageTypeAny, c_unitDamageEither, null);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Auriel - Bestow Hope - Proxy Unit Swapped
//--------------------------------------------------------------------------------------------------
bool libHAUR_gt_HeroAurielBestowHopeProxyUnitSwapped_Func (bool testConds, bool runActions) {
// Variable Declarations
unit lv_oldUnit;
unit lv_newUnit;
unit lv_aurielUnit;
bool lv_preserveOnOld;
// Automatic Variable Declarations
const int auto9EA897AF_ae = libCore_gv_bALMaxPlayers;
int auto9EA897AF_var;
// Variable Initialization
lv_oldUnit = libGame_gf_HeroUnitSwappedForPlayerOldUnit();
lv_newUnit = libGame_gf_HeroUnitSwappedForPlayerNewUnit();
lv_preserveOnOld = libGame_gf_HeroUnitSwappedForPlayerPreserveOnOld();
// Conditions
if (testConds) {
if (!((lv_preserveOnOld == false))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
auto9EA897AF_var = 1;
for ( ; auto9EA897AF_var <= auto9EA897AF_ae; auto9EA897AF_var += 1 ) {
if ((libHAUR_gv_heroAurielBestowHopeProxy[auto9EA897AF_var] == lv_oldUnit)) {
lv_aurielUnit = libGame_gv_players[auto9EA897AF_var].lv_heroUnit;
UnitCreateEffectUnit(lv_aurielUnit, "AurielBestowHopeRemovalSet", lv_oldUnit);
UnitCreateEffectUnit(lv_aurielUnit, "AurielBestowHopeApplicationSet", lv_newUnit);
}
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHAUR_gt_HeroAurielBestowHopeProxyUnitSwapped_Init () {
libHAUR_gt_HeroAurielBestowHopeProxyUnitSwapped = TriggerCreate("libHAUR_gt_HeroAurielBestowHopeProxyUnitSwapped_Func");
TriggerEnable(libHAUR_gt_HeroAurielBestowHopeProxyUnitSwapped, false);
libGame_gf_HeroUnitSwappedForPlayer(libHAUR_gt_HeroAurielBestowHopeProxyUnitSwapped);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Auriel - Ray of Heaven - Ability Used
//--------------------------------------------------------------------------------------------------
bool libHAUR_gt_HeroAurielRayofHeavenAbilityUsed_Func (bool testConds, bool runActions) {
// Variable Declarations
unit lv_auriel;
int lv_aurielPlayer;
fixed lv_aurielCurrentEnergy_Raw;
fixed lv_aurielCurrentEnergy_Percent;
fixed lv_aurielBaseEnergyCap;
// Automatic Variable Declarations
// Variable Initialization
lv_auriel = EventUnit();
lv_aurielPlayer = UnitGetOwner(lv_auriel);
lv_aurielCurrentEnergy_Raw = UnitGetPropertyFixed(lv_auriel, c_unitPropEnergy, c_unitPropCurrent);
lv_aurielCurrentEnergy_Percent = UnitGetPropertyFixed(lv_auriel, c_unitPropEnergyPercent, c_unitPropCurrent);
// Actions
if (!runActions) {
return true;
}
if ((lv_aurielCurrentEnergy_Percent == 100.0) && (PlayerHasTalent(lv_aurielPlayer, "AurielReservoirofHopeRayOfHeavenTalent") == true)) {
UnitCreateEffectUnit(lv_auriel, "AurielRayOfHeavenReservoirOfHopeQuestIncrementToken", lv_auriel);
}
if ((UnitHasBehavior2(lv_auriel, "AurielRayOfHeavenGlimmerofHopePrimed") == true)) {
UnitSetPropertyFixed(lv_auriel, c_unitPropEnergy, (lv_aurielCurrentEnergy_Raw * libHAUR_gv_heroAurielRayofHeavenGlimmerofHopeStoredPercentage));
UnitBehaviorRemove(lv_auriel, "AurielRayOfHeavenGlimmerofHopePrimed", 1);
}
else {
UnitSetPropertyFixed(lv_auriel, c_unitPropEnergy, 0.0);
}
lv_aurielBaseEnergyCap = (UnitGetPropertyFixed(lv_auriel, c_unitPropEnergyMax, c_unitPropCurrent) - (libHAUR_gv_heroAurielRayofHeavenReservoirofHopeHealingPerStack * UnitGetTokenCount(lv_auriel, CatalogFieldValueGet(c_gameCatalogBehavior, "AurielRayOfHeavenReservoirOfHopeQuestToken", "TokenId", c_playerAny))));
CatalogFieldValueSetFixed(c_gameCatalogEffect, "AurielRayOfHeavenCreateHealer", "RechargeVitalRate", lv_aurielPlayer, lv_aurielCurrentEnergy_Raw);
if ((PlayerHasTalent(lv_aurielPlayer, "AurielSearingLightRayOfHeavenTalent") == true)) {
CatalogFieldValueSetFixed(c_gameCatalogEffect, "AurielRayOfHeavenSearingLightHeroDamage", "Amount", lv_aurielPlayer, (lv_aurielCurrentEnergy_Raw * libHAUR_gv_heroAurielRayofHeavenSearingLightFractionOfEnergyConvertedToDamage));
CatalogFieldValueSetFixed(c_gameCatalogEffect, "AurielRayOfHeavenSearingLightNonHeroDamage", "Amount", lv_aurielPlayer, (lv_aurielCurrentEnergy_Raw * libHAUR_gv_heroAurielRayofHeavenSearingLightFractionOfEnergyConvertedToDamage));
}
if ((lv_aurielCurrentEnergy_Raw < (lv_aurielBaseEnergyCap * 0.5))) {
UnitCreateEffectPoint(lv_auriel, "AurielRayOfHeavenLowHealingStoredInitialSet", EventUnitTargetPoint());
}
else {
if ((lv_aurielCurrentEnergy_Raw >= lv_aurielBaseEnergyCap)) {
UnitCreateEffectPoint(lv_auriel, "AurielRayOfHeavenMaxHealingStoredInitialSet", EventUnitTargetPoint());
}
else {
UnitCreateEffectPoint(lv_auriel, "AurielRayOfHeavenHighHealingStoredInitialSet", EventUnitTargetPoint());
}
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHAUR_gt_HeroAurielRayofHeavenAbilityUsed_Init () {
libHAUR_gt_HeroAurielRayofHeavenAbilityUsed = TriggerCreate("libHAUR_gt_HeroAurielRayofHeavenAbilityUsed_Func");
TriggerEnable(libHAUR_gt_HeroAurielRayofHeavenAbilityUsed, false);
TriggerAddEventUnitAbility(libHAUR_gt_HeroAurielRayofHeavenAbilityUsed, null, AbilityCommand("AurielRayOfHeaven", 0), c_abilEffectStageCast, false);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Auriel - Crystal Aegis - Overlay Controller
//--------------------------------------------------------------------------------------------------
bool libHAUR_gt_HeroAurielCrystalAegisOverlayController_Func (bool testConds, bool runActions) {
// Automatic Variable Declarations
// Actions
if (!runActions) {
return true;
}
if ((UnitIsAlive(EventUnit()) == true) && (UnitTestState(EventUnit(), c_unitStateHallucination) == false) && (UnitHasBehavior2(EventUnit(), "HeroGenericIgnoreFullscreenOverlay") == false) && (UnitHasBehavior2(EventUnit(), "AurielCrystalAegisStasisBehavior") == true)) {
libUIUI_gf_FullscreenOverlayAddItemForPlayer(EventPlayer(), libUIUI_ge_FullscreenOverlayPriorities_Stasis, "Cutscenes\\GameUI_StasisOverlay.StormCutscene", EventUnitBehavior());
}
else {
libUIUI_gf_FullscreenOverlayRemoveItemFromQueueForPlayer(EventPlayer(), "Cutscenes\\GameUI_StasisOverlay.StormCutscene", EventUnitBehavior());
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHAUR_gt_HeroAurielCrystalAegisOverlayController_Init () {
libHAUR_gt_HeroAurielCrystalAegisOverlayController = TriggerCreate("libHAUR_gt_HeroAurielCrystalAegisOverlayController_Func");
TriggerEnable(libHAUR_gt_HeroAurielCrystalAegisOverlayController, false);
TriggerAddEventUnitBehaviorChange(libHAUR_gt_HeroAurielCrystalAegisOverlayController, null, "AurielCrystalAegisStasisBehavior", c_unitBehaviorChangeActivate);
TriggerAddEventUnitBehaviorChange(libHAUR_gt_HeroAurielCrystalAegisOverlayController, null, "AurielCrystalAegisStasisBehavior", c_unitBehaviorChangeDestroy);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Auriel - Resurrect - Player Unlocks Resurrect
//--------------------------------------------------------------------------------------------------
bool libHAUR_gt_HeroAurielResurrectPlayerUnlocksResurrect_Func (bool testConds, bool runActions) {
// Variable Declarations
unit lv_auriel;
int lv_aurielPlayer;
int lv_aurielTeam;
// Automatic Variable Declarations
// Variable Initialization
lv_auriel = EventUnit();
lv_aurielPlayer = UnitGetOwner(lv_auriel);
// Conditions
if (testConds) {
if (!((UnitGetType(lv_auriel) == "HeroAuriel"))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
lv_aurielTeam = libGame_gf_TeamNumberOfPlayer(lv_aurielPlayer);
if ((UnitBehaviorCount(lv_auriel, "Ultimate1Unlocked") > 0)) {
libHAUR_gv_heroAurielResurrectRezzersOnTeam[lv_aurielTeam] += 1;
}
else {
libHAUR_gv_heroAurielResurrectRezzersOnTeam[lv_aurielTeam] -= 1;
}
if (((libHAUR_gv_heroAurielResurrectRezzersOnTeam[libGame_gv_teamOrderIndex_C] >= 1) || (libHAUR_gv_heroAurielResurrectRezzersOnTeam[libGame_gv_teamChaosIndex_C] >= 1))) {
TriggerEnable(libHAUR_gt_HeroAurielResurrectCreateSpirit, true);
TriggerEnable(libHAUR_gt_HeroAurielResurrectRevivePlayer, true);
}
else {
TriggerEnable(libHAUR_gt_HeroAurielResurrectCreateSpirit, false);
TriggerEnable(libHAUR_gt_HeroAurielResurrectMurkyEggDeathSpiritReveal, false);
TriggerEnable(libHAUR_gt_HeroAurielResurrectRevivePlayer, false);
TriggerEnable(libHAUR_gt_HeroAurielResurrectPlayerRespawns, false);
TriggerEnable(libHAUR_gt_HeroAurielResurrectLostVikingRespawns, false);
TriggerEnable(libHAUR_gt_HeroAurielResurrectLostVikingsPlayAgainComplete, false);
TriggerEnable(libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveStart, false);
TriggerEnable(libHAUR_gt_HeroAurielResurrectSpiritTimerController, false);
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHAUR_gt_HeroAurielResurrectPlayerUnlocksResurrect_Init () {
libHAUR_gt_HeroAurielResurrectPlayerUnlocksResurrect = TriggerCreate("libHAUR_gt_HeroAurielResurrectPlayerUnlocksResurrect_Func");
TriggerEnable(libHAUR_gt_HeroAurielResurrectPlayerUnlocksResurrect, false);
TriggerAddEventUnitBehaviorChange(libHAUR_gt_HeroAurielResurrectPlayerUnlocksResurrect, null, "Ultimate1Unlocked", c_unitBehaviorChangeCreate);
TriggerAddEventUnitBehaviorChange(libHAUR_gt_HeroAurielResurrectPlayerUnlocksResurrect, null, "Ultimate1Unlocked", c_unitBehaviorChangeDestroy);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Auriel - Resurrect - Player Respecs
//--------------------------------------------------------------------------------------------------
bool libHAUR_gt_HeroAurielResurrectPlayerRespecs_Func (bool testConds, bool runActions) {
// Variable Declarations
int lv_itPlayer;
unit lv_itUnit;
// Automatic Variable Declarations
const int autoFF32B8CF_ae = libCore_gv_bALMaxPlayers;
const int autoFF32B8CF_ai = 1;
// Variable Initialization
// Conditions
if (testConds) {
if (!((UnitGetType(libGame_gv_players[libGame_gf_HeroRespecsTalentsPlayer()].lv_heroUnit) == "HeroAuriel"))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
if ((libHAUR_gv_heroAurielResurrectRezzersOnTeam[libGame_gf_TeamNumberOfPlayer(libGame_gf_HeroRespecsTalentsPlayer())] == 0)) {
lv_itPlayer = 1;
for ( ; ( (autoFF32B8CF_ai >= 0 && lv_itPlayer <= autoFF32B8CF_ae) || (autoFF32B8CF_ai < 0 && lv_itPlayer >= autoFF32B8CF_ae) ) ; lv_itPlayer += autoFF32B8CF_ai ) {
if ((libHAUR_gv_heroAurielResurrectSpirit[lv_itPlayer] != null)) {
UnitRemove(libHAUR_gv_heroAurielResurrectSpirit[lv_itPlayer]);
libHAUR_gv_heroAurielResurrectSpirit[lv_itPlayer] = null;
}
if ((libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_itPlayer][1].lv_spiritUnit != null)) {
UnitRemove(libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_itPlayer][1].lv_spiritUnit);
libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_itPlayer][1].lv_spiritUnit = null;
}
if ((libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_itPlayer][2].lv_spiritUnit != null)) {
UnitRemove(libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_itPlayer][2].lv_spiritUnit);
libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_itPlayer][2].lv_spiritUnit = null;
}
if ((libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_itPlayer][3].lv_spiritUnit != null)) {
UnitRemove(libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_itPlayer][3].lv_spiritUnit);
libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_itPlayer][3].lv_spiritUnit = null;
}
TextTagDestroy(libHAUR_gv_heroAurielResurrectDeadPlayerSpiritTimerTextTag[lv_itPlayer][0]);
TextTagDestroy(libHAUR_gv_heroAurielResurrectDeadPlayerSpiritTimerTextTag[lv_itPlayer][1]);
TextTagDestroy(libHAUR_gv_heroAurielResurrectDeadPlayerSpiritTimerTextTag[lv_itPlayer][2]);
TextTagDestroy(libHAUR_gv_heroAurielResurrectDeadPlayerSpiritTimerTextTag[lv_itPlayer][3]);
TextTagDestroy(libHAUR_gv_heroAurielResurrectAurielSpiritTimerTextTag[lv_itPlayer][0]);
TextTagDestroy(libHAUR_gv_heroAurielResurrectAurielSpiritTimerTextTag[lv_itPlayer][1]);
TextTagDestroy(libHAUR_gv_heroAurielResurrectAurielSpiritTimerTextTag[lv_itPlayer][2]);
TextTagDestroy(libHAUR_gv_heroAurielResurrectAurielSpiritTimerTextTag[lv_itPlayer][3]);
}
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHAUR_gt_HeroAurielResurrectPlayerRespecs_Init () {
libHAUR_gt_HeroAurielResurrectPlayerRespecs = TriggerCreate("libHAUR_gt_HeroAurielResurrectPlayerRespecs_Func");
TriggerEnable(libHAUR_gt_HeroAurielResurrectPlayerRespecs, false);
libGame_gf_HeroRespecsTalents(libHAUR_gt_HeroAurielResurrectPlayerRespecs);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Auriel - Resurrect - Create Spirit
//--------------------------------------------------------------------------------------------------
bool libHAUR_gt_HeroAurielResurrectCreateSpirit_Func (bool testConds, bool runActions) {
// Variable Declarations
unit lv_deadHero;
int lv_deadPlayer;
int lv_deadPlayersTeam;
int lv_iPlayer;
point lv_lastKnownPosition;
// Automatic Variable Declarations
string autoDD7969E0_val;
const int auto6C97AF6C_ae = libCore_gv_bALMaxPlayers;
const int auto6C97AF6C_ai = 1;
const int auto24B82E18_ae = libCore_gv_bALMaxPlayers;
const int auto24B82E18_ai = 1;
// Variable Initialization
lv_deadHero = EventUnit();
lv_deadPlayer = UnitGetOwner(lv_deadHero);
lv_deadPlayersTeam = libGame_gf_TeamNumberOfPlayer(lv_deadPlayer);
lv_iPlayer = 1;
lv_lastKnownPosition = UnitGetPosition(EventUnit());
// Conditions
if (testConds) {
if (!((libHAUR_gv_heroAurielResurrectRezzersOnTeam[lv_deadPlayersTeam] >= 1))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
autoDD7969E0_val = UnitGetType(lv_deadHero);
if (autoDD7969E0_val == "HeroBaleog") {
if ((libGDHL_gv_lostVikingsPlayer[lv_deadPlayer].lv_checkpointReachedDeathTimerActive == false)) {
CatalogFieldValueSet(c_gameCatalogUnit, "AurielResurrectSpirit", "Name", lv_deadPlayer, CatalogFieldValueGet(c_gameCatalogUnit, UnitGetType(libGame_gv_players[lv_deadPlayer].lv_heroUnit), "Name", lv_deadPlayer));
UnitCreate(1, "AurielResurrectSpirit", 0, lv_deadPlayer, UnitGetPosition(lv_deadHero), 270.0, lv_deadHero);
libHAUR_gv_heroAurielResurrectShowSpiritTimer[lv_deadPlayer] = true;
libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer] = UnitLastCreated();
libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_deadPlayer][1].lv_spiritUnit = UnitLastCreated();
libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_deadPlayer][1].lv_vikingUnit = lv_deadHero;
UnitBehaviorAdd(libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_deadPlayer][1].lv_spiritUnit, "AurielResurrectRezzable", libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_deadPlayer][1].lv_spiritUnit, 1);
UnitBehaviorSetDuration(libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_deadPlayer][1].lv_spiritUnit, "AurielResurrectRezzable", (TimerGetDuration(libGDHL_gv_lostVikingsPlayer[lv_deadPlayer].lv_baleogDeathTimer) - libHAUR_gv_heroAurielResurrectTargetUnresurrectableTime));
libHAUR_gf_HeroAurielResurrectRevealSpirittoAurielandDeadPlayer(lv_deadPlayer, lv_deadHero);
TriggerEnable(libHAUR_gt_HeroAurielResurrectLostVikingRespawns, true);
TriggerEnable(libHAUR_gt_HeroAurielResurrectLostVikingsPlayAgainComplete, true);
}
else {
return true;
}
}
else if (autoDD7969E0_val == "HeroFaerieDragon") {
CatalogFieldValueSet(c_gameCatalogUnit, "AurielResurrectSpirit", "Name", lv_deadPlayer, CatalogFieldValueGet(c_gameCatalogUnit, UnitGetType(libGame_gv_players[lv_deadPlayer].lv_heroUnit), "Name", lv_deadPlayer));
UnitCreate(1, "AurielResurrectSpirit", 0, lv_deadPlayer, UnitGetPosition(lv_deadHero), 270.0, lv_deadHero);
libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer] = UnitLastCreated();
UnitSetHeight(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], 1.0, 0.0);
UnitBehaviorAdd(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], "AurielResurrectRezzable", libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], 1);
UnitBehaviorSetDuration(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], "AurielResurrectRezzable", (TimerGetDuration(libGame_gv_players[lv_deadPlayer].lv_respawnTimer) - libHAUR_gv_heroAurielResurrectTargetUnresurrectableTime));
libHAUR_gf_HeroAurielResurrectRevealSpirittoAurielandDeadPlayer(lv_deadPlayer, lv_deadHero);
}
else if (autoDD7969E0_val == "HeroDiablo") {
Wait(0.125, c_timeGame);
if ((TimerGetDuration(libGame_gv_players[lv_deadPlayer].lv_respawnTimer) <= libHAUR_gv_heroAurielResurrectTargetUnresurrectableTime)) {
}
else {
CatalogFieldValueSet(c_gameCatalogUnit, "AurielResurrectSpirit", "Name", lv_deadPlayer, CatalogFieldValueGet(c_gameCatalogUnit, UnitGetType(libGame_gv_players[lv_deadPlayer].lv_heroUnit), "Name", lv_deadPlayer));
UnitCreate(1, "AurielResurrectSpirit", 0, lv_deadPlayer, UnitGetPosition(lv_deadHero), 270.0, lv_deadHero);
libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer] = UnitLastCreated();
UnitSetPosition(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], lv_lastKnownPosition, false);
UnitBehaviorAdd(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], "AurielResurrectRezzable", libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], 1);
UnitBehaviorSetDuration(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], "AurielResurrectRezzable", (TimerGetDuration(libGame_gv_players[lv_deadPlayer].lv_respawnTimer) - libHAUR_gv_heroAurielResurrectTargetUnresurrectableTime));
libHAUR_gf_HeroAurielResurrectRevealSpirittoAurielandDeadPlayer(lv_deadPlayer, lv_deadHero);
}
}
else if (autoDD7969E0_val == "HeroErik") {
if ((libGDHL_gv_lostVikingsPlayer[lv_deadPlayer].lv_checkpointReachedDeathTimerActive == false)) {
CatalogFieldValueSet(c_gameCatalogUnit, "AurielResurrectSpirit", "Name", lv_deadPlayer, CatalogFieldValueGet(c_gameCatalogUnit, UnitGetType(libGame_gv_players[lv_deadPlayer].lv_heroUnit), "Name", lv_deadPlayer));
UnitCreate(1, "AurielResurrectSpirit", 0, lv_deadPlayer, UnitGetPosition(lv_deadHero), 270.0, lv_deadHero);
libHAUR_gv_heroAurielResurrectShowSpiritTimer[lv_deadPlayer] = true;
libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer] = UnitLastCreated();
libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_deadPlayer][2].lv_spiritUnit = UnitLastCreated();
libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_deadPlayer][2].lv_vikingUnit = lv_deadHero;
UnitBehaviorAdd(libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_deadPlayer][2].lv_spiritUnit, "AurielResurrectRezzable", libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_deadPlayer][2].lv_spiritUnit, 1);
UnitBehaviorSetDuration(libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_deadPlayer][2].lv_spiritUnit, "AurielResurrectRezzable", (TimerGetDuration(libGDHL_gv_lostVikingsPlayer[lv_deadPlayer].lv_erikDeathTimer) - libHAUR_gv_heroAurielResurrectTargetUnresurrectableTime));
libHAUR_gf_HeroAurielResurrectRevealSpirittoAurielandDeadPlayer(lv_deadPlayer, lv_deadHero);
TriggerEnable(libHAUR_gt_HeroAurielResurrectLostVikingRespawns, true);
TriggerEnable(libHAUR_gt_HeroAurielResurrectLostVikingsPlayAgainComplete, true);
}
else {
return true;
}
}
else if (autoDD7969E0_val == "HeroL90ETC") {
if ((UnitHasBehavior2(lv_deadHero, "L90ETCDeathMetalCarryBehavior") == false)) {
CatalogFieldValueSet(c_gameCatalogUnit, "AurielResurrectSpirit", "Name", lv_deadPlayer, CatalogFieldValueGet(c_gameCatalogUnit, UnitGetType(libGame_gv_players[lv_deadPlayer].lv_heroUnit), "Name", lv_deadPlayer));
UnitCreate(1, "AurielResurrectSpirit", 0, lv_deadPlayer, UnitGetPosition(lv_deadHero), 270.0, lv_deadHero);
libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer] = UnitLastCreated();
UnitSetPosition(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], lv_lastKnownPosition, false);
UnitBehaviorAdd(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], "AurielResurrectRezzable", libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], 1);
UnitBehaviorSetDuration(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], "AurielResurrectRezzable", (TimerGetDuration(libGame_gv_players[lv_deadPlayer].lv_respawnTimer) - libHAUR_gv_heroAurielResurrectTargetUnresurrectableTime));
libHAUR_gf_HeroAurielResurrectRevealSpirittoAurielandDeadPlayer(lv_deadPlayer, lv_deadHero);
}
else {
UnitCreate(1, "AurielResurrectSpirit", 0, UnitGetOwner(lv_deadHero), UnitGetPosition(lv_deadHero), 270.0, lv_deadHero);
libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer] = UnitLastCreated();
UnitSetPosition(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], lv_lastKnownPosition, false);
UnitBehaviorAdd(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], "AurielResurrectRezzable", libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], 1);
UnitBehaviorSetDuration(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], "AurielResurrectRezzable", (TimerGetDuration(libGame_gv_players[lv_deadPlayer].lv_respawnTimer) - libHAUR_gv_heroAurielResurrectTargetUnresurrectableTime));
Wait(CatalogFieldValueGetAsFixed(c_gameCatalogBehavior, "L90ETCDeathMetalTimedLife", "Duration", UnitGetOwner(lv_deadHero)), c_timeGame);
libHAUR_gf_HeroAurielResurrectRevealSpirittoAurielandDeadPlayer(lv_deadPlayer, lv_deadHero);
}
}
else if (autoDD7969E0_val == "HeroFalstad") {
CatalogFieldValueSet(c_gameCatalogUnit, "AurielResurrectSpirit", "Name", lv_deadPlayer, CatalogFieldValueGet(c_gameCatalogUnit, UnitGetType(libGame_gv_players[lv_deadPlayer].lv_heroUnit), "Name", lv_deadPlayer));
UnitCreate(1, "AurielResurrectSpirit", 0, lv_deadPlayer, UnitGetPosition(lv_deadHero), 270.0, lv_deadHero);
libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer] = UnitLastCreated();
UnitSetHeight(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], 2.0, 0.0);
UnitBehaviorAdd(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], "AurielResurrectRezzable", libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], 1);
UnitBehaviorSetDuration(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], "AurielResurrectRezzable", (TimerGetDuration(libGame_gv_players[lv_deadPlayer].lv_respawnTimer) - libHAUR_gv_heroAurielResurrectTargetUnresurrectableTime));
libHAUR_gf_HeroAurielResurrectRevealSpirittoAurielandDeadPlayer(lv_deadPlayer, lv_deadHero);
}
else if (autoDD7969E0_val == "HeroGall") {
return true;
}
else if (autoDD7969E0_val == "HeroLeoric") {
libHAUR_gv_heroAurielResurrectLeoricUnit[lv_deadPlayer] = lv_deadHero;
CatalogFieldValueSet(c_gameCatalogUnit, "AurielResurrectSpirit", "Name", lv_deadPlayer, CatalogFieldValueGet(c_gameCatalogUnit, UnitGetType(libGame_gv_players[lv_deadPlayer].lv_heroUnit), "Name", lv_deadPlayer));
UnitCreate(1, "AurielResurrectSpirit", 0, lv_deadPlayer, UnitGetPosition(lv_deadHero), 270.0, lv_deadHero);
libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer] = UnitLastCreated();
UnitSetPosition(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], lv_lastKnownPosition, false);
UnitBehaviorAdd(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], "AurielResurrectRezzable", libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], 1);
UnitBehaviorSetDuration(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], "AurielResurrectRezzable", (TimerGetDuration(libGame_gv_players[lv_deadPlayer].lv_respawnTimer) - libHAUR_gv_heroAurielResurrectTargetUnresurrectableTime));
TriggerEnable(libHAUR_gt_HeroAurielResurrectLeoricSpiritFollow, true);
lv_iPlayer = 1;
for ( ; ( (auto6C97AF6C_ai >= 0 && lv_iPlayer <= auto6C97AF6C_ae) || (auto6C97AF6C_ai < 0 && lv_iPlayer >= auto6C97AF6C_ae) ) ; lv_iPlayer += auto6C97AF6C_ai ) {
if (((UnitGetType(libGame_gv_players[lv_iPlayer].lv_heroUnit) == "HeroAuriel") && (libGame_gf_TeamNumberOfPlayer(lv_deadPlayer) == libGame_gf_TeamNumberOfPlayer(lv_iPlayer)))) {
ActorSend(libNtve_gf_MainActorofUnit(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer]), libNtve_gf_Signal(("Auriel" + IntToString(lv_iPlayer))));
}
}
ActorSend(libNtve_gf_MainActorofUnit(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer]), libNtve_gf_ModelSwap("HitTestFuzzy_Cyliner", 0));
ActorSend(libNtve_gf_MainActorofUnit(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer]), libNtve_gf_SetOpacity(0.0, 0));
ActorSend(libNtve_gf_MainActorofUnit(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer]), libNtve_gf_SetScale(2.0, 2.0, 4.5, 0.0));
ActorSend(libNtve_gf_MainActorofUnit(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer]), libNtve_gf_SetHeight(1.0));
}
else if (autoDD7969E0_val == "HeroMurky") {
CatalogFieldValueSet(c_gameCatalogUnit, "AurielResurrectSpirit", "Name", lv_deadPlayer, CatalogFieldValueGet(c_gameCatalogUnit, UnitGetType(libGame_gv_players[lv_deadPlayer].lv_heroUnit), "Name", lv_deadPlayer));
UnitCreate(1, "AurielResurrectSpirit", 0, lv_deadPlayer, UnitGetPosition(lv_deadHero), 270.0, lv_deadHero);
libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer] = UnitLastCreated();
UnitSetPosition(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], lv_lastKnownPosition, false);
UnitBehaviorAdd(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], "AurielResurrectRezzable", libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], 1);
UnitBehaviorSetDuration(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], "AurielResurrectRezzable", (TimerGetDuration(libGame_gv_players[lv_deadPlayer].lv_respawnTimer) - libHAUR_gv_heroAurielResurrectTargetUnresurrectableTime));
ActorSend(libNtve_gf_MainActorofUnit(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer]), libNtve_gf_ModelSwap(libCore_gf_GetModelLinkForUnitType(UnitGetType(lv_deadHero)), 0));
if ((UnitIsAlive(libGame_gv_heroDeathMurkyRespawnEggs[lv_deadPlayer]) == true)) {
TriggerEnable(libHAUR_gt_HeroAurielResurrectMurkyEggDeathSpiritReveal, true);
return true;
}
else {
lv_iPlayer = 1;
for ( ; ( (auto24B82E18_ai >= 0 && lv_iPlayer <= auto24B82E18_ae) || (auto24B82E18_ai < 0 && lv_iPlayer >= auto24B82E18_ae) ) ; lv_iPlayer += auto24B82E18_ai ) {
if (((UnitGetType(libGame_gv_players[lv_iPlayer].lv_heroUnit) == "HeroAuriel") && (libGame_gf_TeamNumberOfPlayer(lv_deadPlayer) == libGame_gf_TeamNumberOfPlayer(lv_iPlayer)))) {
ActorSend(libNtve_gf_MainActorofUnit(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer]), libNtve_gf_Signal(("Auriel" + IntToString(lv_iPlayer))));
ActorSend(libNtve_gf_MainActorofUnit(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer]), libNtve_gf_Signal(("Auriel" + IntToString(lv_deadPlayer))));
ActorSend(libNtve_gf_MainActorofUnit(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer]), libNtve_gf_Signal("Taunt"));
libHAUR_gv_heroAurielResurrectShowSpiritTimer[lv_deadPlayer] = true;
}
}
}
}
else if (autoDD7969E0_val == "HeroOlaf") {
if ((libGDHL_gv_lostVikingsPlayer[lv_deadPlayer].lv_checkpointReachedDeathTimerActive == false)) {
CatalogFieldValueSet(c_gameCatalogUnit, "AurielResurrectSpirit", "Name", lv_deadPlayer, CatalogFieldValueGet(c_gameCatalogUnit, UnitGetType(libGame_gv_players[lv_deadPlayer].lv_heroUnit), "Name", lv_deadPlayer));
UnitCreate(1, "AurielResurrectSpirit", 0, lv_deadPlayer, UnitGetPosition(lv_deadHero), 270.0, lv_deadHero);
libHAUR_gv_heroAurielResurrectShowSpiritTimer[lv_deadPlayer] = true;
libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer] = UnitLastCreated();
libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_deadPlayer][3].lv_spiritUnit = UnitLastCreated();
libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_deadPlayer][3].lv_vikingUnit = lv_deadHero;
UnitBehaviorAdd(libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_deadPlayer][3].lv_spiritUnit, "AurielResurrectRezzable", libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_deadPlayer][3].lv_spiritUnit, 1);
UnitBehaviorSetDuration(libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_deadPlayer][3].lv_spiritUnit, "AurielResurrectRezzable", (TimerGetDuration(libGDHL_gv_lostVikingsPlayer[lv_deadPlayer].lv_olafDeathTimer) - libHAUR_gv_heroAurielResurrectTargetUnresurrectableTime));
libHAUR_gf_HeroAurielResurrectRevealSpirittoAurielandDeadPlayer(lv_deadPlayer, lv_deadHero);
TriggerEnable(libHAUR_gt_HeroAurielResurrectLostVikingRespawns, true);
TriggerEnable(libHAUR_gt_HeroAurielResurrectLostVikingsPlayAgainComplete, true);
}
else {
return true;
}
}
else if (autoDD7969E0_val == "HeroTyrael") {
CatalogFieldValueSet(c_gameCatalogUnit, "AurielResurrectSpirit", "Name", lv_deadPlayer, CatalogFieldValueGet(c_gameCatalogUnit, UnitGetType(libGame_gv_players[lv_deadPlayer].lv_heroUnit), "Name", lv_deadPlayer));
UnitCreate(1, "AurielResurrectSpirit", 0, lv_deadPlayer, UnitGetPosition(lv_deadHero), 270.0, lv_deadHero);
libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer] = UnitLastCreated();
while ((UnitHasBehavior2(lv_deadHero, "TyraelArchangelsWrathDeathActiveBuff") == true)) {
lv_lastKnownPosition = UnitGetPosition(lv_deadHero);
Wait(0.0625, c_timeGame);
}
UnitSetPosition(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], lv_lastKnownPosition, false);
UnitBehaviorAdd(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], "AurielResurrectRezzable", libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], 1);
UnitBehaviorSetDuration(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], "AurielResurrectRezzable", (TimerGetDuration(libGame_gv_players[lv_deadPlayer].lv_respawnTimer) - (libHAUR_gv_heroAurielResurrectTargetUnresurrectableTime + CatalogFieldValueGetAsFixed(c_gameCatalogBehavior, "TyraelArchangelsWrathDeathActiveBuff", "Duration", lv_deadPlayer))));
libHAUR_gf_HeroAurielResurrectRevealSpirittoAurielandDeadPlayer(lv_deadPlayer, lv_deadHero);
}
else if (autoDD7969E0_val == "HeroUther") {
if (((PlayerHasTalent(lv_deadPlayer, "UtherMasteryRedemption") == true) && (UnitHasBehavior2(lv_deadHero, "RedemptionCooldown") == false))) {
}
else {
CatalogFieldValueSet(c_gameCatalogUnit, "AurielResurrectSpirit", "Name", lv_deadPlayer, CatalogFieldValueGet(c_gameCatalogUnit, UnitGetType(libGame_gv_players[lv_deadPlayer].lv_heroUnit), "Name", lv_deadPlayer));
UnitCreate(1, "AurielResurrectSpirit", 0, lv_deadPlayer, UnitGetPosition(lv_deadHero), 270.0, lv_deadHero);
libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer] = UnitLastCreated();
while (((UnitHasBehavior2(lv_deadHero, "SpiritOfRedemptionSpiritFormBuff") == true) || (UnitHasBehavior2(lv_deadHero, "UtherEternalVanguardRezDelay") == true))) {
Wait(0.0625, c_timeGame);
lv_lastKnownPosition = UnitGetPosition(lv_deadHero);
}
UnitSetPosition(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], lv_lastKnownPosition, false);
UnitBehaviorAdd(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], "AurielResurrectRezzable", libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], 1);
UnitBehaviorSetDuration(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], "AurielResurrectRezzable", (TimerGetDuration(libGame_gv_players[lv_deadPlayer].lv_respawnTimer) - (libHAUR_gv_heroAurielResurrectTargetUnresurrectableTime + (CatalogFieldValueGetAsFixed(c_gameCatalogBehavior, "SpiritOfRedemptionSpiritFormBuff", "Duration", lv_deadPlayer) + CatalogFieldValueGetAsFixed(c_gameCatalogBehavior, "UtherEternalVanguardRezDelay", "Duration", lv_deadPlayer)))));
libHAUR_gf_HeroAurielResurrectRevealSpirittoAurielandDeadPlayer(lv_deadPlayer, lv_deadHero);
}
}
else if (autoDD7969E0_val == "HeroVarian") {
CatalogFieldValueSet(c_gameCatalogUnit, "AurielResurrectSpirit", "Name", lv_deadPlayer, CatalogFieldValueGet(c_gameCatalogUnit, UnitGetType(libGame_gv_players[lv_deadPlayer].lv_heroUnit), "Name", lv_deadPlayer));
UnitCreate(1, "AurielResurrectSpirit", 0, lv_deadPlayer, UnitGetPosition(lv_deadHero), 270.0, lv_deadHero);
libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer] = UnitLastCreated();
UnitBehaviorAdd(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], "AurielResurrectRezzable", libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], 1);
UnitBehaviorSetDuration(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], "AurielResurrectRezzable", (TimerGetDuration(libGame_gv_players[lv_deadPlayer].lv_respawnTimer) - libHAUR_gv_heroAurielResurrectTargetUnresurrectableTime));
libHAUR_gf_HeroAurielResurrectRevealSpirittoAurielandDeadPlayer(lv_deadPlayer, lv_deadHero);
if ((UnitHasBehavior2(lv_deadHero, "Ultimate1Unlocked") == true)) {
ActorSendAsText(libNtve_gf_MainActorofUnit(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer]), StringExternal("Param/Value/lib_HAUR_01A53FA0"));
ActorSendAsText(libNtve_gf_MainActorofUnit(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer]), StringExternal("Param/Value/lib_HAUR_2B5616E7"));
}
if ((UnitHasBehavior2(lv_deadHero, "Ultimate2Unlocked") == true)) {
ActorSendAsText(libNtve_gf_MainActorofUnit(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer]), StringExternal("Param/Value/lib_HAUR_8820D07D"));
ActorSendAsText(libNtve_gf_MainActorofUnit(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer]), StringExternal("Param/Value/lib_HAUR_60FB7DE7"));
ActorSendAsText(libNtve_gf_MainActorofUnit(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer]), StringExternal("Param/Value/lib_HAUR_69526BC8"));
}
if ((UnitHasBehavior2(lv_deadHero, "Ultimate3Unlocked") == true)) {
ActorSendAsText(libNtve_gf_MainActorofUnit(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer]), StringExternal("Param/Value/lib_HAUR_08EA24F8"));
ActorSendAsText(libNtve_gf_MainActorofUnit(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer]), StringExternal("Param/Value/lib_HAUR_36739258"));
}
if ((UnitHasBehavior2(lv_deadHero, "Ultimate1Unlocked") == false) && (UnitHasBehavior2(lv_deadHero, "Ultimate2Unlocked") == false) && (UnitHasBehavior2(lv_deadHero, "Ultimate3Unlocked") == false)) {
ActorSendAsText(libNtve_gf_MainActorofUnit(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer]), StringExternal("Param/Value/lib_HAUR_A5770B1C"));
ActorSendAsText(libNtve_gf_MainActorofUnit(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer]), StringExternal("Param/Value/lib_HAUR_7A962816"));
}
}
else if (autoDD7969E0_val == "RexxarMisha") {
return true;
}
else if (autoDD7969E0_val == "HeroDeathwing") {
return true;
}
else if (autoDD7969E0_val == "BaleogsGravestone") {
return true;
}
else if (autoDD7969E0_val == "EriksGravestone") {
return true;
}
else if (autoDD7969E0_val == "OlafsGravestone") {
return true;
}
else {
CatalogFieldValueSet(c_gameCatalogUnit, "AurielResurrectSpirit", "Name", lv_deadPlayer, CatalogFieldValueGet(c_gameCatalogUnit, UnitGetType(libGame_gv_players[lv_deadPlayer].lv_heroUnit), "Name", lv_deadPlayer));
UnitCreate(1, "AurielResurrectSpirit", 0, lv_deadPlayer, UnitGetPosition(lv_deadHero), 270.0, lv_deadHero);
libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer] = UnitLastCreated();
UnitBehaviorAdd(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], "AurielResurrectRezzable", libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], 1);
UnitBehaviorSetDuration(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], "AurielResurrectRezzable", (TimerGetDuration(libGame_gv_players[lv_deadPlayer].lv_respawnTimer) - libHAUR_gv_heroAurielResurrectTargetUnresurrectableTime));
libHAUR_gf_HeroAurielResurrectRevealSpirittoAurielandDeadPlayer(lv_deadPlayer, lv_deadHero);
}
libHAUR_gf_HeroAurielResurrectCheckActiveSpirits(true);
return true;
}
//--------------------------------------------------------------------------------------------------
void libHAUR_gt_HeroAurielResurrectCreateSpirit_Init () {
libHAUR_gt_HeroAurielResurrectCreateSpirit = TriggerCreate("libHAUR_gt_HeroAurielResurrectCreateSpirit_Func");
TriggerEnable(libHAUR_gt_HeroAurielResurrectCreateSpirit, false);
TriggerAddEventUnitBehaviorChange(libHAUR_gt_HeroAurielResurrectCreateSpirit, null, "Dead", c_unitBehaviorChangeIncrease);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Auriel - Resurrect - Murky Egg Death Spirit Reveal
//--------------------------------------------------------------------------------------------------
bool libHAUR_gt_HeroAurielResurrectMurkyEggDeathSpiritReveal_Func (bool testConds, bool runActions) {
// Variable Declarations
int lv_murkyPlayer;
int lv_murkyPlayersTeam;
unit lv_murky;
unit lv_murkyEgg;
unit lv_murkySpirit;
int lv_iPlayer;
// Automatic Variable Declarations
const int autoF754AA34_ae = libCore_gv_bALMaxPlayers;
const int autoF754AA34_ai = 1;
// Variable Initialization
lv_murkyPlayersTeam = libGame_gf_TeamNumberOfPlayer(UnitGetOwner(EventUnit()));
lv_iPlayer = 1;
// Conditions
if (testConds) {
if (!(((UnitGetType(EventUnit()) == "MurkyRespawnEgg") && (libHAUR_gv_heroAurielResurrectRezzersOnTeam[lv_murkyPlayersTeam] >= 1)))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
lv_murkyEgg = EventUnit();
lv_murkyPlayer = UnitGetOwner(EventUnit());
lv_murkySpirit = libHAUR_gv_heroAurielResurrectSpirit[lv_murkyPlayer];
lv_murky = libGame_gv_players[lv_murkyPlayer].lv_heroUnit;
if ((UnitHasBehavior2(lv_murky, "Dead") == true)) {
lv_iPlayer = 1;
for ( ; ( (autoF754AA34_ai >= 0 && lv_iPlayer <= autoF754AA34_ae) || (autoF754AA34_ai < 0 && lv_iPlayer >= autoF754AA34_ae) ) ; lv_iPlayer += autoF754AA34_ai ) {
if (((UnitGetType(libGame_gv_players[lv_iPlayer].lv_heroUnit) == "HeroAuriel") && (libGame_gf_TeamNumberOfPlayer(lv_iPlayer) == libGame_gf_TeamNumberOfPlayer(lv_murkyPlayer)))) {
ActorSend(libNtve_gf_MainActorofUnit(libHAUR_gv_heroAurielResurrectSpirit[lv_murkyPlayer]), libNtve_gf_Signal(("Auriel" + IntToString(lv_iPlayer))));
ActorSend(libNtve_gf_MainActorofUnit(libHAUR_gv_heroAurielResurrectSpirit[lv_murkyPlayer]), libNtve_gf_Signal(("Auriel" + IntToString(lv_murkyPlayer))));
ActorSend(libNtve_gf_MainActorofUnit(libHAUR_gv_heroAurielResurrectSpirit[lv_murkyPlayer]), libNtve_gf_Signal("Taunt"));
libHAUR_gv_heroAurielResurrectShowSpiritTimer[lv_murkyPlayer] = true;
libHAUR_gf_HeroAurielResurrectCheckActiveSpirits(true);
}
}
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHAUR_gt_HeroAurielResurrectMurkyEggDeathSpiritReveal_Init () {
libHAUR_gt_HeroAurielResurrectMurkyEggDeathSpiritReveal = TriggerCreate("libHAUR_gt_HeroAurielResurrectMurkyEggDeathSpiritReveal_Func");
TriggerEnable(libHAUR_gt_HeroAurielResurrectMurkyEggDeathSpiritReveal, false);
TriggerAddEventUnitDied(libHAUR_gt_HeroAurielResurrectMurkyEggDeathSpiritReveal, null);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Auriel - Resurrect - Leoric Spirit Follow
//--------------------------------------------------------------------------------------------------
bool libHAUR_gt_HeroAurielResurrectLeoricSpiritFollow_Func (bool testConds, bool runActions) {
// Variable Declarations
int lv_iPlayer;
int lv_deadLeorics;
fixed lv_unrezzableTimeDifference;
unit lv_leoric;
// Automatic Variable Declarations
const int auto01D5D958_ae = libCore_gv_bALMaxPlayers;
const int auto01D5D958_ai = 1;
// Variable Initialization
lv_iPlayer = 1;
lv_unrezzableTimeDifference = 3.25;
// Actions
if (!runActions) {
return true;
}
lv_iPlayer = 1;
for ( ; ( (auto01D5D958_ai >= 0 && lv_iPlayer <= auto01D5D958_ae) || (auto01D5D958_ai < 0 && lv_iPlayer >= auto01D5D958_ae) ) ; lv_iPlayer += auto01D5D958_ai ) {
lv_leoric = libGame_gv_players[lv_iPlayer].lv_heroUnit;
if (((UnitGetType(lv_leoric) == "HeroLeoric") && (UnitHasBehavior2(lv_leoric, "LeoricUndying") == true))) {
UnitSetPosition(libHAUR_gv_heroAurielResurrectSpirit[lv_iPlayer], UnitGetPosition(libHAUR_gv_heroAurielResurrectLeoricUnit[lv_iPlayer]), false);
UnitSetFacing(libHAUR_gv_heroAurielResurrectSpirit[lv_iPlayer], UnitGetFacing(libHAUR_gv_heroAurielResurrectLeoricUnit[lv_iPlayer]), 0.0);
UnitBehaviorSetDurationRemaining(libHAUR_gv_heroAurielResurrectSpirit[lv_iPlayer], "AurielResurrectRezzable", (TimerGetRemaining(libGame_gv_players[lv_iPlayer].lv_respawnTimer) - lv_unrezzableTimeDifference));
lv_deadLeorics += 1;
}
}
if ((lv_deadLeorics == 0)) {
TriggerEnable(TriggerGetCurrent(), false);
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHAUR_gt_HeroAurielResurrectLeoricSpiritFollow_Init () {
libHAUR_gt_HeroAurielResurrectLeoricSpiritFollow = TriggerCreate("libHAUR_gt_HeroAurielResurrectLeoricSpiritFollow_Func");
TriggerEnable(libHAUR_gt_HeroAurielResurrectLeoricSpiritFollow, false);
TriggerAddEventTimePeriodic(libHAUR_gt_HeroAurielResurrectLeoricSpiritFollow, 0.25, c_timeGame);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Auriel - Resurrect - Revive Player
//--------------------------------------------------------------------------------------------------
bool libHAUR_gt_HeroAurielResurrectRevivePlayer_Func (bool testConds, bool runActions) {
// Variable Declarations
int lv_resurrectingTimer;
int lv_timerTextTag;
unit lv_auriel;
unit lv_target;
int lv_aurielPlayer;
int lv_targetPlayer;
unit lv_targetHero;
point lv_targetPosition;
int lv_additionalPlayer;
playergroup lv_vOGroup;
unit lv_deadHero;
int lv_itViking;
// Automatic Variable Declarations
int auto3502FC51_ae;
string auto3E028A26_val;
int auto45FC9C2D_ae;
// Variable Initialization
lv_resurrectingTimer = FixedToInt(libHAUR_gv_heroAurielResurrectResurrectTime);
lv_timerTextTag = c_textTagNone;
lv_auriel = EventPlayerEffectUsedUnit(c_effectUnitCaster);
lv_target = EventPlayerEffectUsedUnit(c_effectUnitTarget);
lv_aurielPlayer = UnitGetOwner(lv_auriel);
lv_targetPlayer = UnitGetOwner(lv_target);
lv_targetPosition = UnitGetPosition(lv_target);
lv_vOGroup = PlayerGroupEmpty();
// Actions
if (!runActions) {
return true;
}
if ((EventPlayerEffectUsed() == "AurielResurrectInitialDummy")) {
lv_targetHero = libGame_gv_players[lv_targetPlayer].lv_heroUnit;
}
else {
lv_targetHero = libGame_gv_players[lv_aurielPlayer].lv_heroUnit;
lv_target = EventPlayerEffectUsedUnit(c_effectUnitCaster);
lv_targetPosition = UnitGetPosition(libHAUR_gv_heroAurielResurrectSpirit[lv_aurielPlayer]);
UnitCreateEffectUnit(lv_target, "AurielResurrectApplyActivelyResurrecting", libHAUR_gv_heroAurielResurrectSpirit[lv_aurielPlayer]);
UnitCreateEffectUnit(lv_target, "AurielResurrectApplySelfMarkerBehavior", libHAUR_gv_heroAurielResurrectSpirit[lv_aurielPlayer]);
}
if ((UnitHasBehavior2(lv_targetHero, "LeoricUndying") == true)) {
UnitCreateEffectUnit(lv_targetHero, "LeoricUndyingApplySuppressHealing5Seconds", lv_targetHero);
}
if ((UnitGetType(libGame_gv_players[lv_targetPlayer].lv_heroUnit) == "HeroLostVikingsController")) {
auto3502FC51_ae = 3;
lv_itViking = 1;
for ( ; lv_itViking <= auto3502FC51_ae ; lv_itViking += 1 ) {
if ((lv_target == libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_targetPlayer][lv_itViking].lv_spiritUnit)) {
lv_targetHero = libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_targetPlayer][lv_itViking].lv_vikingUnit;
UnitCreateEffectUnit(lv_targetHero, "LostVikingsPlayAgainApplySuppressResurrection5Seconds", lv_targetHero);
auto3E028A26_val = UnitGetType(lv_targetHero);
if (auto3E028A26_val == "HeroErik") {
libGDHL_gf_VikingDownStartRespawnTimer(lv_targetHero, libGDHL_gv_lostVikingsPlayer[lv_targetPlayer].lv_erikDeathTimer, true, lv_resurrectingTimer, UnitGetType(lv_targetHero));
break;
}
else if (auto3E028A26_val == "HeroBaleog") {
libGDHL_gf_VikingDownStartRespawnTimer(lv_targetHero, libGDHL_gv_lostVikingsPlayer[lv_targetPlayer].lv_baleogDeathTimer, true, lv_resurrectingTimer, UnitGetType(lv_targetHero));
break;
}
else if (auto3E028A26_val == "HeroOlaf") {
libGDHL_gf_VikingDownStartRespawnTimer(lv_targetHero, libGDHL_gv_lostVikingsPlayer[lv_targetPlayer].lv_olafDeathTimer, true, lv_resurrectingTimer, UnitGetType(lv_targetHero));
break;
}
else {
}
}
}
}
else {
libGame_gf_HeroDeathUpdateRespawnTimer(lv_targetPlayer, lv_resurrectingTimer);
}
DialogDestroy(libHAUR_gv_heroAurielResurrectRevivingDialog[lv_targetPlayer]);
libUIUI_gf_UIPartyFrameSpecialCaseAurielRevivesHero(lv_targetPlayer, lv_targetHero);
if ((UnitGetType(libGame_gv_players[lv_targetPlayer].lv_heroUnit) == "HeroCho")) {
lv_additionalPlayer = libGDHL_gv_chogallPairs[libGame_gf_TeamNumberOfPlayer(lv_targetPlayer)].lv_gallPlayer;
DialogDestroy(libHAUR_gv_heroAurielResurrectRevivingDialog[lv_additionalPlayer]);
TextTagDestroy(libHAUR_gv_heroAurielResurrectDeadPlayerSpiritTimerTextTag[lv_additionalPlayer][0]);
TextTagDestroy(libHAUR_gv_heroAurielResurrectDeadPlayerSpiritTimerTextTag[lv_additionalPlayer][1]);
TextTagDestroy(libHAUR_gv_heroAurielResurrectDeadPlayerSpiritTimerTextTag[lv_additionalPlayer][2]);
TextTagDestroy(libHAUR_gv_heroAurielResurrectDeadPlayerSpiritTimerTextTag[lv_additionalPlayer][3]);
}
TextTagDestroy(libHAUR_gv_heroAurielResurrectDeadPlayerSpiritTimerTextTag[lv_targetPlayer][0]);
TextTagDestroy(libHAUR_gv_heroAurielResurrectDeadPlayerSpiritTimerTextTag[lv_targetPlayer][1]);
TextTagDestroy(libHAUR_gv_heroAurielResurrectDeadPlayerSpiritTimerTextTag[lv_targetPlayer][2]);
TextTagDestroy(libHAUR_gv_heroAurielResurrectDeadPlayerSpiritTimerTextTag[lv_targetPlayer][3]);
TextTagDestroy(libHAUR_gv_heroAurielResurrectAurielSpiritTimerTextTag[lv_targetPlayer][0]);
TextTagDestroy(libHAUR_gv_heroAurielResurrectAurielSpiritTimerTextTag[lv_targetPlayer][1]);
TextTagDestroy(libHAUR_gv_heroAurielResurrectAurielSpiritTimerTextTag[lv_targetPlayer][2]);
TextTagDestroy(libHAUR_gv_heroAurielResurrectAurielSpiritTimerTextTag[lv_targetPlayer][3]);
TextExpressionSetToken("Param/Expression/lib_HAUR_67088ACF", "A", StringExternal("Param/Value/lib_HAUR_41A946DA"));
TextExpressionSetToken("Param/Expression/lib_HAUR_67088ACF", "B", IntToText(lv_resurrectingTimer));
TextTagCreate(TextExpressionAssemble("Param/Expression/lib_HAUR_67088ACF"), 24, lv_targetPosition, 3.0, true, true, PlayerGroupAll());
lv_timerTextTag = TextTagLastCreated();
while ((lv_resurrectingTimer > 0)) {
TextExpressionSetToken("Param/Expression/lib_HAUR_EEA6032B", "A", StringExternal("Param/Value/lib_HAUR_147401C8"));
TextExpressionSetToken("Param/Expression/lib_HAUR_EEA6032B", "B", IntToText(lv_resurrectingTimer));
TextTagSetText(lv_timerTextTag, TextExpressionAssemble("Param/Expression/lib_HAUR_EEA6032B"));
lv_resurrectingTimer -= 1;
Wait(1.0, c_timeGame);
}
TextTagDestroy(lv_timerTextTag);
if ((UnitGetType(lv_targetHero) == "HeroMurky")) {
UnitSetPosition(lv_targetHero, lv_targetPosition, false);
}
if ((libGame_gv_players[lv_targetPlayer].lv_heroRequiresCustomRespawn == true)) {
libGame_gf_SendEventRequestCustomRespawn(lv_targetPlayer, false, lv_targetPosition, libHAUR_gv_heroAurielResurrectVitalScale);
UnitRemove(libHAUR_gv_heroAurielResurrectSpirit[lv_targetPlayer]);
libHAUR_gv_heroAurielResurrectSpirit[lv_targetPlayer] = null;
}
else {
if ((UnitGetType(libGame_gv_players[lv_targetPlayer].lv_heroUnit) == "HeroLostVikingsController")) {
auto45FC9C2D_ae = 3;
lv_itViking = 1;
for ( ; lv_itViking <= auto45FC9C2D_ae ; lv_itViking += 1 ) {
if ((lv_target == libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_targetPlayer][lv_itViking].lv_spiritUnit)) {
libGDHL_gf_VikingDownRespawnVikingforPlayer(lv_targetHero);
UnitSetPosition(lv_targetHero, lv_targetPosition, false);
UnitSetPropertyFixed(lv_targetHero, c_unitPropLifePercent, libHAUR_gv_heroAurielResurrectVitalScale);
UnitRemove(libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_targetPlayer][lv_itViking].lv_spiritUnit);
libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_targetPlayer][lv_itViking].lv_spiritUnit = null;
}
}
}
else {
libGame_gf_HeroDeathRespawnHeroforPlayer(false, lv_targetPlayer, lv_targetPosition, libHAUR_gv_heroAurielResurrectVitalScale);
UnitRemove(libHAUR_gv_heroAurielResurrectSpirit[lv_targetPlayer]);
libHAUR_gv_heroAurielResurrectSpirit[lv_targetPlayer] = null;
}
}
UnitBehaviorRemove(libGame_gv_players[lv_targetPlayer].lv_heroUnit, "AurielResurrectPendingResurrect", 1);
if (((PlayerHasTalent(lv_aurielPlayer, "AurielLightSpeedResurrectTalent") == true) && (UnitHasBehavior2(lv_targetHero, "LeoricUndying") == false))) {
UnitCreateEffectUnit(lv_auriel, "AurielResurrectLightSpeedApplyControllerBehavior", lv_targetHero);
UnitCreateEffectUnit(lv_auriel, "AurielResurrectLightSpeedApplySpeedBehavior", lv_targetHero);
}
libNtve_gf_StopTimer(libGame_gv_players[lv_targetPlayer].lv_respawnSoundCueTimer);
libNtve_gf_StopTimer(libGame_gv_players[lv_targetPlayer].lv_respawnTimer);
UnitCreateEffectUnit(lv_auriel, "AurielResurrectWingsDummy", lv_targetHero);
UnitBehaviorRemove(lv_targetHero, "HallOfStormsHealBuff", 1);
UnitBehaviorRemove(lv_targetHero, "HallOfStormsProtectionBuff", 1);
ActorSend(ActorFromActor(libNtve_gf_MainActorofUnit(lv_targetHero), "HallOfStormsHealBuffFX"), "Destroy Immediate");
if ((UnitGetType(libGame_gv_players[lv_targetPlayer].lv_heroUnit) == "HeroLostVikingsController")) {
if ((libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_targetPlayer][1].lv_spiritUnit == null) && (libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_targetPlayer][2].lv_spiritUnit == null) && (libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_targetPlayer][3].lv_spiritUnit == null)) {
libHAUR_gv_heroAurielResurrectShowSpiritTimer[lv_targetPlayer] = false;
}
}
else {
libHAUR_gv_heroAurielResurrectShowSpiritTimer[lv_targetPlayer] = false;
}
if ((UnitHasBehavior2(lv_targetHero, "LeoricUndying") == true)) {
UnitBehaviorAdd(lv_targetHero, "LeoricUndyingReviveHalfVitals", lv_targetHero, 1);
UnitBehaviorRemove(lv_targetHero, "LeoricUndying", 1);
UnitSetPropertyFixed(lv_targetHero, c_unitPropLifePercent, libHAUR_gv_heroAurielResurrectVitalScale);
UnitSetPropertyFixed(lv_targetHero, c_unitPropEnergyPercent, libHAUR_gv_heroAurielResurrectEnergyPercentage);
if ((PlayerHasTalent(lv_aurielPlayer, "AurielLightSpeedResurrectTalent") == true)) {
UnitCreateEffectUnit(lv_auriel, "AurielResurrectLightSpeedApplyControllerBehavior", lv_targetHero);
UnitCreateEffectUnit(lv_auriel, "AurielResurrectLightSpeedApplySpeedBehavior", lv_targetHero);
}
}
libHAUR_gv_heroAurielResurrectTotalActiveResurrectActions -= 1;
if ((libHAUR_gv_heroAurielResurrectTotalActiveResurrectActions <= 0)) {
}
libHAUR_gv_heroAurielResurrectFrameRecords[lv_aurielPlayer].lv_heroAurielResurrectTargetTeam = 0;
libHAUR_gv_heroAurielResurrectFrameRecords[lv_aurielPlayer].lv_heroAurielResurrectTargetFrameIndex = 0;
libGame_gf_HeroDeathEnableDisableDeadSoundStateForPlayer(false, lv_targetPlayer);
PlayerGroupAdd(lv_vOGroup, lv_aurielPlayer);
PlayerGroupAdd(lv_vOGroup, lv_targetPlayer);
libSond_gf_HeroVOPlayResurrected(lv_targetPlayer, lv_vOGroup);
libHAUR_gf_HeroAurielResurrectCheckActiveSpirits(false);
return true;
}
//--------------------------------------------------------------------------------------------------
void libHAUR_gt_HeroAurielResurrectRevivePlayer_Init () {
libHAUR_gt_HeroAurielResurrectRevivePlayer = TriggerCreate("libHAUR_gt_HeroAurielResurrectRevivePlayer_Func");
TriggerEnable(libHAUR_gt_HeroAurielResurrectRevivePlayer, false);
TriggerAddEventPlayerEffectUsed(libHAUR_gt_HeroAurielResurrectRevivePlayer, c_playerAny, "AurielResurrectInitialDummy");
TriggerAddEventPlayerEffectUsed(libHAUR_gt_HeroAurielResurrectRevivePlayer, c_playerAny, "AurielResurrectSelfDummy");
}
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Auriel - Resurrect - Player Respawns
//--------------------------------------------------------------------------------------------------
bool libHAUR_gt_HeroAurielResurrectPlayerRespawns_Func (bool testConds, bool runActions) {
// Variable Declarations
int lv_iPlayer;
// Automatic Variable Declarations
const int auto39C4077E_ae = libCore_gv_bALMaxPlayers;
const int auto39C4077E_ai = 1;
// Variable Initialization
lv_iPlayer = 1;
// Conditions
if (testConds) {
if (!((libGame_gv_gameOver == false))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
lv_iPlayer = 1;
for ( ; ( (auto39C4077E_ai >= 0 && lv_iPlayer <= auto39C4077E_ae) || (auto39C4077E_ai < 0 && lv_iPlayer >= auto39C4077E_ae) ) ; lv_iPlayer += auto39C4077E_ai ) {
if ((EventTimer() == libGame_gv_players[lv_iPlayer].lv_respawnTimer) && (libHAUR_gv_heroAurielResurrectSpirit[lv_iPlayer] != null)) {
UnitRemove(libHAUR_gv_heroAurielResurrectSpirit[lv_iPlayer]);
DialogDestroy(libHAUR_gv_heroAurielResurrectRevivingDialog[lv_iPlayer]);
libHAUR_gv_heroAurielResurrectShowSpiritTimer[lv_iPlayer] = false;
libHAUR_gf_HeroAurielResurrectCheckActiveSpirits(false);
TextTagDestroy(libHAUR_gv_heroAurielResurrectDeadPlayerSpiritTimerTextTag[lv_iPlayer][0]);
TextTagDestroy(libHAUR_gv_heroAurielResurrectDeadPlayerSpiritTimerTextTag[lv_iPlayer][1]);
TextTagDestroy(libHAUR_gv_heroAurielResurrectDeadPlayerSpiritTimerTextTag[lv_iPlayer][2]);
TextTagDestroy(libHAUR_gv_heroAurielResurrectDeadPlayerSpiritTimerTextTag[lv_iPlayer][3]);
TextTagDestroy(libHAUR_gv_heroAurielResurrectAurielSpiritTimerTextTag[lv_iPlayer][0]);
TextTagDestroy(libHAUR_gv_heroAurielResurrectAurielSpiritTimerTextTag[lv_iPlayer][1]);
TextTagDestroy(libHAUR_gv_heroAurielResurrectAurielSpiritTimerTextTag[lv_iPlayer][2]);
TextTagDestroy(libHAUR_gv_heroAurielResurrectAurielSpiritTimerTextTag[lv_iPlayer][3]);
}
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHAUR_gt_HeroAurielResurrectPlayerRespawns_Init () {
libHAUR_gt_HeroAurielResurrectPlayerRespawns = TriggerCreate("libHAUR_gt_HeroAurielResurrectPlayerRespawns_Func");
TriggerEnable(libHAUR_gt_HeroAurielResurrectPlayerRespawns, false);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectPlayerRespawns, libGame_gv_players[1].lv_respawnTimer);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectPlayerRespawns, libGame_gv_players[2].lv_respawnTimer);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectPlayerRespawns, libGame_gv_players[3].lv_respawnTimer);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectPlayerRespawns, libGame_gv_players[4].lv_respawnTimer);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectPlayerRespawns, libGame_gv_players[5].lv_respawnTimer);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectPlayerRespawns, libGame_gv_players[6].lv_respawnTimer);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectPlayerRespawns, libGame_gv_players[7].lv_respawnTimer);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectPlayerRespawns, libGame_gv_players[8].lv_respawnTimer);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectPlayerRespawns, libGame_gv_players[9].lv_respawnTimer);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectPlayerRespawns, libGame_gv_players[10].lv_respawnTimer);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Auriel - Resurrect - Lost Viking Respawns
//--------------------------------------------------------------------------------------------------
bool libHAUR_gt_HeroAurielResurrectLostVikingRespawns_Func (bool testConds, bool runActions) {
// Variable Declarations
int lv_iPlayer;
// Automatic Variable Declarations
const int auto1DB0779E_ae = libCore_gv_bALMaxPlayers;
const int auto1DB0779E_ai = 1;
timer autoE60BF628_val;
// Variable Initialization
lv_iPlayer = 1;
// Conditions
if (testConds) {
if (!((libGame_gv_gameOver == false))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
lv_iPlayer = 1;
for ( ; ( (auto1DB0779E_ai >= 0 && lv_iPlayer <= auto1DB0779E_ae) || (auto1DB0779E_ai < 0 && lv_iPlayer >= auto1DB0779E_ae) ) ; lv_iPlayer += auto1DB0779E_ai ) {
autoE60BF628_val = EventTimer();
if (autoE60BF628_val == libGDHL_gv_lostVikingsPlayer[lv_iPlayer].lv_baleogDeathTimer) {
UnitRemove(libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_iPlayer][1].lv_spiritUnit);
libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_iPlayer][1].lv_spiritUnit = null;
DialogDestroy(libHAUR_gv_heroAurielResurrectRevivingDialog[lv_iPlayer]);
break;
}
else if (autoE60BF628_val == libGDHL_gv_lostVikingsPlayer[lv_iPlayer].lv_erikDeathTimer) {
UnitRemove(libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_iPlayer][2].lv_spiritUnit);
libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_iPlayer][2].lv_spiritUnit = null;
DialogDestroy(libHAUR_gv_heroAurielResurrectRevivingDialog[lv_iPlayer]);
break;
}
else if (autoE60BF628_val == libGDHL_gv_lostVikingsPlayer[lv_iPlayer].lv_olafDeathTimer) {
UnitRemove(libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_iPlayer][3].lv_spiritUnit);
libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_iPlayer][3].lv_spiritUnit = null;
DialogDestroy(libHAUR_gv_heroAurielResurrectRevivingDialog[lv_iPlayer]);
break;
}
else {
}
}
if ((libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_iPlayer][1].lv_spiritUnit == null) && (libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_iPlayer][2].lv_spiritUnit == null) && (libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_iPlayer][3].lv_spiritUnit == null)) {
libHAUR_gv_heroAurielResurrectShowSpiritTimer[lv_iPlayer] = false;
}
libHAUR_gf_HeroAurielResurrectCheckActiveSpirits(false);
return true;
}
//--------------------------------------------------------------------------------------------------
void libHAUR_gt_HeroAurielResurrectLostVikingRespawns_Init () {
libHAUR_gt_HeroAurielResurrectLostVikingRespawns = TriggerCreate("libHAUR_gt_HeroAurielResurrectLostVikingRespawns_Func");
TriggerEnable(libHAUR_gt_HeroAurielResurrectLostVikingRespawns, false);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectLostVikingRespawns, libGDHL_gv_lostVikingsPlayer[1].lv_erikDeathTimer);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectLostVikingRespawns, libGDHL_gv_lostVikingsPlayer[1].lv_baleogDeathTimer);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectLostVikingRespawns, libGDHL_gv_lostVikingsPlayer[1].lv_olafDeathTimer);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectLostVikingRespawns, libGDHL_gv_lostVikingsPlayer[2].lv_erikDeathTimer);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectLostVikingRespawns, libGDHL_gv_lostVikingsPlayer[2].lv_baleogDeathTimer);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectLostVikingRespawns, libGDHL_gv_lostVikingsPlayer[2].lv_olafDeathTimer);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectLostVikingRespawns, libGDHL_gv_lostVikingsPlayer[3].lv_erikDeathTimer);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectLostVikingRespawns, libGDHL_gv_lostVikingsPlayer[3].lv_baleogDeathTimer);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectLostVikingRespawns, libGDHL_gv_lostVikingsPlayer[3].lv_olafDeathTimer);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectLostVikingRespawns, libGDHL_gv_lostVikingsPlayer[4].lv_erikDeathTimer);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectLostVikingRespawns, libGDHL_gv_lostVikingsPlayer[4].lv_baleogDeathTimer);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectLostVikingRespawns, libGDHL_gv_lostVikingsPlayer[4].lv_olafDeathTimer);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectLostVikingRespawns, libGDHL_gv_lostVikingsPlayer[5].lv_erikDeathTimer);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectLostVikingRespawns, libGDHL_gv_lostVikingsPlayer[5].lv_baleogDeathTimer);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectLostVikingRespawns, libGDHL_gv_lostVikingsPlayer[5].lv_olafDeathTimer);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectLostVikingRespawns, libGDHL_gv_lostVikingsPlayer[6].lv_erikDeathTimer);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectLostVikingRespawns, libGDHL_gv_lostVikingsPlayer[6].lv_baleogDeathTimer);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectLostVikingRespawns, libGDHL_gv_lostVikingsPlayer[6].lv_olafDeathTimer);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectLostVikingRespawns, libGDHL_gv_lostVikingsPlayer[7].lv_erikDeathTimer);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectLostVikingRespawns, libGDHL_gv_lostVikingsPlayer[7].lv_baleogDeathTimer);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectLostVikingRespawns, libGDHL_gv_lostVikingsPlayer[7].lv_olafDeathTimer);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectLostVikingRespawns, libGDHL_gv_lostVikingsPlayer[8].lv_erikDeathTimer);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectLostVikingRespawns, libGDHL_gv_lostVikingsPlayer[8].lv_baleogDeathTimer);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectLostVikingRespawns, libGDHL_gv_lostVikingsPlayer[8].lv_olafDeathTimer);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectLostVikingRespawns, libGDHL_gv_lostVikingsPlayer[9].lv_erikDeathTimer);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectLostVikingRespawns, libGDHL_gv_lostVikingsPlayer[9].lv_baleogDeathTimer);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectLostVikingRespawns, libGDHL_gv_lostVikingsPlayer[9].lv_olafDeathTimer);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectLostVikingRespawns, libGDHL_gv_lostVikingsPlayer[10].lv_erikDeathTimer);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectLostVikingRespawns, libGDHL_gv_lostVikingsPlayer[10].lv_baleogDeathTimer);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectLostVikingRespawns, libGDHL_gv_lostVikingsPlayer[10].lv_olafDeathTimer);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Auriel - Resurrect - Lost Vikings Play Again Complete
//--------------------------------------------------------------------------------------------------
bool libHAUR_gt_HeroAurielResurrectLostVikingsPlayAgainComplete_Func (bool testConds, bool runActions) {
// Variable Declarations
int lv_lVPlayer;
int lv_itViking;
// Automatic Variable Declarations
const int auto51E10A0D_ae = 3;
const int auto51E10A0D_ai = 1;
// Variable Initialization
lv_lVPlayer = EventPlayerEffectUsedUnitOwner(c_effectPlayerCaster);
// Actions
if (!runActions) {
return true;
}
DialogDestroy(libHAUR_gv_heroAurielResurrectRevivingDialog[lv_lVPlayer]);
libHAUR_gv_heroAurielResurrectShowSpiritTimer[lv_lVPlayer] = false;
TextTagDestroy(libHAUR_gv_heroAurielResurrectDeadPlayerSpiritTimerTextTag[lv_lVPlayer][0]);
TextTagDestroy(libHAUR_gv_heroAurielResurrectDeadPlayerSpiritTimerTextTag[lv_lVPlayer][1]);
TextTagDestroy(libHAUR_gv_heroAurielResurrectDeadPlayerSpiritTimerTextTag[lv_lVPlayer][2]);
TextTagDestroy(libHAUR_gv_heroAurielResurrectDeadPlayerSpiritTimerTextTag[lv_lVPlayer][3]);
TextTagDestroy(libHAUR_gv_heroAurielResurrectAurielSpiritTimerTextTag[lv_lVPlayer][0]);
TextTagDestroy(libHAUR_gv_heroAurielResurrectAurielSpiritTimerTextTag[lv_lVPlayer][1]);
TextTagDestroy(libHAUR_gv_heroAurielResurrectAurielSpiritTimerTextTag[lv_lVPlayer][2]);
TextTagDestroy(libHAUR_gv_heroAurielResurrectAurielSpiritTimerTextTag[lv_lVPlayer][3]);
lv_itViking = 1;
for ( ; ( (auto51E10A0D_ai >= 0 && lv_itViking <= auto51E10A0D_ae) || (auto51E10A0D_ai < 0 && lv_itViking >= auto51E10A0D_ae) ) ; lv_itViking += auto51E10A0D_ai ) {
if ((UnitIsValid(libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_lVPlayer][lv_itViking].lv_spiritUnit) == true) && (UnitBehaviorCount(libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_lVPlayer][lv_itViking].lv_vikingUnit, "LostVikingsPlayAgainSuppressResurrection") == 0)) {
UnitRemove(libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_lVPlayer][lv_itViking].lv_spiritUnit);
UnitBehaviorAdd(libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_lVPlayer][lv_itViking].lv_spiritUnit, "AurielResurrectNotRezzable", libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_lVPlayer][lv_itViking].lv_spiritUnit, 1);
libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_lVPlayer][lv_itViking].lv_spiritUnit = null;
libHAUR_gf_HeroAurielResurrectCheckActiveSpirits(false);
}
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHAUR_gt_HeroAurielResurrectLostVikingsPlayAgainComplete_Init () {
libHAUR_gt_HeroAurielResurrectLostVikingsPlayAgainComplete = TriggerCreate("libHAUR_gt_HeroAurielResurrectLostVikingsPlayAgainComplete_Func");
TriggerEnable(libHAUR_gt_HeroAurielResurrectLostVikingsPlayAgainComplete, false);
TriggerAddEventPlayerEffectUsed(libHAUR_gt_HeroAurielResurrectLostVikingsPlayAgainComplete, c_playerAny, "LostVikingsPlayAgainFinalSet");
}
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Auriel - Resurrect - Lost Vikings Play Again Start
//--------------------------------------------------------------------------------------------------
bool libHAUR_gt_HeroAurielResurrectLostVikingsPlayAgainStart_Func (bool testConds, bool runActions) {
// Variable Declarations
int lv_i;
unit lv_caster;
int lv_lVPlayer;
// Automatic Variable Declarations
const int auto1618AADE_ae = 3;
const int auto1618AADE_ai = 1;
const int auto77871593_ae = 3;
const int auto77871593_ai = 1;
// Variable Initialization
lv_caster = EventUnit();
lv_lVPlayer = UnitGetOwner(EventUnit());
// Conditions
if (testConds) {
if (!((UnitGetOwner(lv_caster) >= 1))) {
return false;
}
if (!((UnitGetOwner(lv_caster) <= libCore_gv_bALMaxPlayers))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
lv_i = 1;
for ( ; ( (auto1618AADE_ai >= 0 && lv_i <= auto1618AADE_ae) || (auto1618AADE_ai < 0 && lv_i >= auto1618AADE_ae) ) ; lv_i += auto1618AADE_ai ) {
if ((UnitIsValid(libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_lVPlayer][lv_i].lv_spiritUnit) == true)) {
UnitBehaviorAdd(libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_lVPlayer][lv_i].lv_spiritUnit, "AurielResurrectNotRezzable", libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_lVPlayer][lv_i].lv_spiritUnit, 1);
}
}
while ((UnitBehaviorCount(lv_caster, "LostVikingsPlayAgainActivelyCasting") == 1)) {
Wait(0.0625, c_timeGame);
}
lv_i = 1;
for ( ; ( (auto77871593_ai >= 0 && lv_i <= auto77871593_ae) || (auto77871593_ai < 0 && lv_i >= auto77871593_ae) ) ; lv_i += auto77871593_ai ) {
if ((UnitIsValid(libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_lVPlayer][lv_i].lv_spiritUnit) == true)) {
UnitBehaviorRemove(libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_lVPlayer][lv_i].lv_spiritUnit, "AurielResurrectNotRezzable", 1);
}
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHAUR_gt_HeroAurielResurrectLostVikingsPlayAgainStart_Init () {
libHAUR_gt_HeroAurielResurrectLostVikingsPlayAgainStart = TriggerCreate("libHAUR_gt_HeroAurielResurrectLostVikingsPlayAgainStart_Func");
TriggerEnable(libHAUR_gt_HeroAurielResurrectLostVikingsPlayAgainStart, false);
TriggerAddEventUnitAbility(libHAUR_gt_HeroAurielResurrectLostVikingsPlayAgainStart, null, AbilityCommand("LostVikingsPlayAgain", 0), c_abilEffectStagePrep, false);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Auriel - Resurrect - Notify Target Player Revive Start
//--------------------------------------------------------------------------------------------------
bool libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveStart_Func (bool testConds, bool runActions) {
// Variable Declarations
unit lv_auriel;
int lv_aurielPlayer;
unit lv_target;
int lv_targetPlayer;
point lv_targetPoint;
unit lv_spiritUnit;
int lv_additionalPlayer;
int lv_iPlayer;
int lv_itViking;
// Automatic Variable Declarations
int auto223356F4_ae;
const int auto734F05FC_ae = libCore_gv_bALMaxPlayers;
const int auto734F05FC_ai = 1;
// Variable Initialization
lv_iPlayer = 1;
lv_itViking = 1;
// Conditions
if (testConds) {
if (!((UnitIsValid(EventPlayerEffectUsedUnit(c_effectUnitTarget)) == true))) {
return false;
}
}
// Actions
if (!runActions) {
return true;
}
TriggerEnable(libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveInterrupted, true);
lv_auriel = EventPlayerEffectUsedUnit(c_effectUnitCaster);
lv_target = EventPlayerEffectUsedUnit(c_effectUnitTarget);
lv_aurielPlayer = UnitGetOwner(lv_auriel);
lv_targetPlayer = UnitGetOwner(lv_target);
lv_targetPoint = UnitGetPosition(lv_target);
CameraPan(lv_targetPlayer, lv_targetPoint, 1.0, -1, 10.0, false);
UnitBehaviorAdd(libGame_gv_players[lv_targetPlayer].lv_heroUnit, "AurielResurrectPendingResurrect", lv_auriel, 1);
DialogDestroy(libHAUR_gv_heroAurielResurrectRevivingDialog[lv_targetPlayer]);
DialogCreate(1920, 150, c_anchorCenter, 0, 0, true);
libHAUR_gv_heroAurielResurrectRevivingDialog[lv_targetPlayer] = DialogLastCreated();
DialogSetImageVisible(libHAUR_gv_heroAurielResurrectRevivingDialog[lv_targetPlayer], false);
DialogSetVisible(libHAUR_gv_heroAurielResurrectRevivingDialog[lv_targetPlayer], PlayerGroupSingle(lv_targetPlayer), true);
DialogControlCreateFromTemplate(libHAUR_gv_heroAurielResurrectRevivingDialog[lv_targetPlayer], c_triggerControlTypeLabel, "Auriel/AurielResurrectionNotificationTemplate");
TextExpressionSetToken("Param/Expression/lib_HAUR_7D4E4562", "AurielUnit", libHAUR_gf_AurielUIUnitDisplayName(lv_auriel));
libNtve_gf_SetDialogItemText(DialogControlLastCreated(), TextExpressionAssemble("Param/Expression/lib_HAUR_7D4E4562"), PlayerGroupAll());
if ((UnitGetType(libGame_gv_players[lv_targetPlayer].lv_heroUnit) == "HeroLostVikingsController")) {
auto223356F4_ae = 3;
lv_itViking = 1;
for ( ; lv_itViking <= auto223356F4_ae ; lv_itViking += 1 ) {
if ((lv_target == libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_targetPlayer][lv_itViking].lv_spiritUnit)) {
lv_spiritUnit = libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_targetPlayer][lv_itViking].lv_spiritUnit;
}
}
}
else {
lv_spiritUnit = libHAUR_gv_heroAurielResurrectSpirit[lv_targetPlayer];
}
lv_iPlayer = 1;
for ( ; ( (auto734F05FC_ai >= 0 && lv_iPlayer <= auto734F05FC_ae) || (auto734F05FC_ai < 0 && lv_iPlayer >= auto734F05FC_ae) ) ; lv_iPlayer += auto734F05FC_ai ) {
if (((lv_iPlayer != lv_aurielPlayer) && (lv_iPlayer != lv_targetPlayer))) {
ActorSend(libNtve_gf_MainActorofUnit(lv_spiritUnit), libNtve_gf_Signal(("Auriel" + IntToString(lv_iPlayer))));
}
}
ActorSend(libNtve_gf_MainActorofUnit(lv_spiritUnit), libNtve_gf_Signal("Cheer"));
TimerPause(libHAUR_gv_heroAurielResurrectNotifyTargetPlayerReviveInterruptedTimer[lv_targetPlayer], true);
if ((UnitGetType(libGame_gv_players[lv_targetPlayer].lv_heroUnit) == "HeroCho")) {
lv_additionalPlayer = libGDHL_gv_chogallPairs[libGame_gf_TeamNumberOfPlayer(lv_targetPlayer)].lv_gallPlayer;
DialogDestroy(libHAUR_gv_heroAurielResurrectRevivingDialog[lv_additionalPlayer]);
CameraPan(lv_additionalPlayer, lv_targetPoint, 1.0, -1, 10.0, false);
DialogSetVisible(libHAUR_gv_heroAurielResurrectRevivingDialog[lv_targetPlayer], PlayerGroupSingle(lv_additionalPlayer), true);
ActorSend(libNtve_gf_MainActorofUnit(libHAUR_gv_heroAurielResurrectSpirit[lv_targetPlayer]), libNtve_gf_Signal(("Auriel" + IntToString(lv_additionalPlayer))));
TimerPause(libHAUR_gv_heroAurielResurrectNotifyTargetPlayerReviveInterruptedTimer[lv_additionalPlayer], true);
}
if ((UnitHasBehavior2(libGame_gv_players[lv_targetPlayer].lv_heroUnit, "LeoricUndying") == true)) {
UnitBehaviorAdd(libGame_gv_players[lv_targetPlayer].lv_heroUnit, "AurielResurrectMobileSpiritRoot", lv_auriel, 1);
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveStart_Init () {
libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveStart = TriggerCreate("libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveStart_Func");
TriggerEnable(libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveStart, false);
TriggerAddEventPlayerEffectUsed(libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveStart, c_playerAny, "AurielResurrectPrepareSet");
}
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Auriel - Resurrect - Notify Target Player Revive Interrupted
//--------------------------------------------------------------------------------------------------
bool libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveInterrupted_Func (bool testConds, bool runActions) {
// Variable Declarations
unit lv_auriel;
int lv_aurielPlayer;
unit lv_target;
int lv_targetPlayer;
point lv_targetPoint;
int lv_additionalPlayer;
unit lv_spiritUnit;
int lv_iPlayer;
int lv_itViking;
// Automatic Variable Declarations
int auto02F993A8_ae;
const int auto641F5BCE_ae = libCore_gv_bALMaxPlayers;
const int auto641F5BCE_ai = 1;
// Variable Initialization
lv_iPlayer = 1;
lv_itViking = 1;
// Actions
if (!runActions) {
return true;
}
lv_auriel = EventUnit();
lv_target = EventUnitTargetUnit();
lv_aurielPlayer = UnitGetOwner(lv_auriel);
lv_targetPlayer = UnitGetOwner(lv_target);
lv_targetPoint = UnitGetPosition(lv_target);
if ((UnitGetType(libGame_gv_players[lv_targetPlayer].lv_heroUnit) == "HeroLostVikingsController")) {
auto02F993A8_ae = 3;
lv_itViking = 1;
for ( ; lv_itViking <= auto02F993A8_ae ; lv_itViking += 1 ) {
if ((lv_target == libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_targetPlayer][lv_itViking].lv_spiritUnit)) {
lv_spiritUnit = libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_targetPlayer][lv_itViking].lv_spiritUnit;
}
}
}
else {
lv_spiritUnit = libHAUR_gv_heroAurielResurrectSpirit[lv_targetPlayer];
}
lv_iPlayer = 1;
for ( ; ( (auto641F5BCE_ai >= 0 && lv_iPlayer <= auto641F5BCE_ae) || (auto641F5BCE_ai < 0 && lv_iPlayer >= auto641F5BCE_ae) ) ; lv_iPlayer += auto641F5BCE_ai ) {
if ((lv_iPlayer != lv_aurielPlayer) && (lv_iPlayer != lv_targetPlayer)) {
ActorSend(libNtve_gf_MainActorofUnit(lv_spiritUnit), libNtve_gf_Signal(("Auriel" + IntToString(lv_iPlayer))));
}
}
CameraPan(lv_targetPlayer, lv_targetPoint, 1.0, -1, 10.0, false);
DialogDestroy(libHAUR_gv_heroAurielResurrectRevivingDialog[lv_targetPlayer]);
DialogCreate(1920, 150, c_anchorCenter, 0, 0, true);
libHAUR_gv_heroAurielResurrectRevivingDialog[lv_targetPlayer] = DialogLastCreated();
DialogSetImageVisible(libHAUR_gv_heroAurielResurrectRevivingDialog[lv_targetPlayer], false);
DialogSetVisible(libHAUR_gv_heroAurielResurrectRevivingDialog[lv_targetPlayer], PlayerGroupSingle(lv_targetPlayer), true);
DialogControlCreateFromTemplate(libHAUR_gv_heroAurielResurrectRevivingDialog[lv_targetPlayer], c_triggerControlTypeLabel, "Auriel/AurielResurrectionNotificationTemplate");
libNtve_gf_SetDialogItemText(DialogControlLastCreated(), StringExternal("Param/Value/lib_HAUR_ECD463CB"), PlayerGroupAll());
TimerStart(libHAUR_gv_heroAurielResurrectNotifyTargetPlayerReviveInterruptedTimer[lv_targetPlayer], 2.0, false, c_timeGame);
if ((UnitGetType(libGame_gv_players[lv_targetPlayer].lv_heroUnit) == "HeroCho")) {
lv_additionalPlayer = libGDHL_gv_chogallPairs[libGame_gf_TeamNumberOfPlayer(lv_targetPlayer)].lv_gallPlayer;
ActorSend(libNtve_gf_MainActorofUnit(libHAUR_gv_heroAurielResurrectSpirit[lv_targetPlayer]), libNtve_gf_Signal(("Auriel" + IntToString(lv_additionalPlayer))));
CameraPan(lv_additionalPlayer, lv_targetPoint, 1.0, -1, 10.0, false);
DialogSetVisible(libHAUR_gv_heroAurielResurrectRevivingDialog[lv_targetPlayer], PlayerGroupSingle(lv_additionalPlayer), true);
TimerStart(libHAUR_gv_heroAurielResurrectNotifyTargetPlayerReviveInterruptedTimer[lv_additionalPlayer], 2.0, false, c_timeGame);
}
UnitBehaviorRemove(libHAUR_gv_heroAurielResurrectSpirit[lv_targetPlayer], "AurielResurrectMarkerBehavior", 1);
if ((UnitHasBehavior2(libGame_gv_players[lv_targetPlayer].lv_heroUnit, "LeoricUndying") == true)) {
UnitBehaviorRemove(libGame_gv_players[lv_targetPlayer].lv_heroUnit, "AurielResurrectMobileSpiritRoot", 1);
}
UnitBehaviorRemove(libGame_gv_players[lv_targetPlayer].lv_heroUnit, "AurielResurrectPendingResurrect", 1);
TriggerEnable(TriggerGetCurrent(), false);
return true;
}
//--------------------------------------------------------------------------------------------------
void libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveInterrupted_Init () {
libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveInterrupted = TriggerCreate("libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveInterrupted_Func");
TriggerEnable(libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveInterrupted, false);
TriggerAddEventUnitAbility(libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveInterrupted, null, AbilityCommand("AurielResurrect", 0), c_unitAbilStageCancel, false);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Auriel - Resurrect - Notify Target Player Revive Interrupted Timer Expired
//--------------------------------------------------------------------------------------------------
bool libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveInterruptedTimerExpired_Func (bool testConds, bool runActions) {
// Variable Declarations
int lv_itPlayer;
// Automatic Variable Declarations
const int auto361A27A8_ae = libCore_gv_bALMaxPlayers;
const int auto361A27A8_ai = 1;
// Variable Initialization
// Actions
if (!runActions) {
return true;
}
lv_itPlayer = 1;
for ( ; ( (auto361A27A8_ai >= 0 && lv_itPlayer <= auto361A27A8_ae) || (auto361A27A8_ai < 0 && lv_itPlayer >= auto361A27A8_ae) ) ; lv_itPlayer += auto361A27A8_ai ) {
if ((libHAUR_gv_heroAurielResurrectNotifyTargetPlayerReviveInterruptedTimer[lv_itPlayer] == EventTimer())) {
DialogDestroy(libHAUR_gv_heroAurielResurrectRevivingDialog[lv_itPlayer]);
}
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveInterruptedTimerExpired_Init () {
libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveInterruptedTimerExpired = TriggerCreate("libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveInterruptedTimerExpired_Func");
TriggerEnable(libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveInterruptedTimerExpired, false);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveInterruptedTimerExpired, libHAUR_gv_heroAurielResurrectNotifyTargetPlayerReviveInterruptedTimer[1]);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveInterruptedTimerExpired, libHAUR_gv_heroAurielResurrectNotifyTargetPlayerReviveInterruptedTimer[2]);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveInterruptedTimerExpired, libHAUR_gv_heroAurielResurrectNotifyTargetPlayerReviveInterruptedTimer[3]);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveInterruptedTimerExpired, libHAUR_gv_heroAurielResurrectNotifyTargetPlayerReviveInterruptedTimer[4]);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveInterruptedTimerExpired, libHAUR_gv_heroAurielResurrectNotifyTargetPlayerReviveInterruptedTimer[5]);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveInterruptedTimerExpired, libHAUR_gv_heroAurielResurrectNotifyTargetPlayerReviveInterruptedTimer[6]);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveInterruptedTimerExpired, libHAUR_gv_heroAurielResurrectNotifyTargetPlayerReviveInterruptedTimer[7]);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveInterruptedTimerExpired, libHAUR_gv_heroAurielResurrectNotifyTargetPlayerReviveInterruptedTimer[8]);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveInterruptedTimerExpired, libHAUR_gv_heroAurielResurrectNotifyTargetPlayerReviveInterruptedTimer[9]);
TriggerAddEventTimer(libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveInterruptedTimerExpired, libHAUR_gv_heroAurielResurrectNotifyTargetPlayerReviveInterruptedTimer[10]);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Auriel - Resurrect - Spirit Timer Controller
//--------------------------------------------------------------------------------------------------
bool libHAUR_gt_HeroAurielResurrectSpiritTimerController_Func (bool testConds, bool runActions) {
// Variable Declarations
int lv_aurielPlayer;
int lv_deadPlayer;
int lv_deadPlayerTeam;
// Automatic Variable Declarations
const int autoF062E6D8_ae = libCore_gv_bALMaxPlayers;
const int autoF062E6D8_ai = 1;
const int autoD32A93E3_ae = libCore_gv_bALMaxPlayers;
const int autoD32A93E3_ai = 1;
string auto1A136385_val;
// Variable Initialization
lv_deadPlayer = 1;
// Actions
if (!runActions) {
return true;
}
lv_deadPlayer = 1;
for ( ; ( (autoF062E6D8_ai >= 0 && lv_deadPlayer <= autoF062E6D8_ae) || (autoF062E6D8_ai < 0 && lv_deadPlayer >= autoF062E6D8_ae) ) ; lv_deadPlayer += autoF062E6D8_ai ) {
if (((TimerGetRemaining(libGame_gv_players[lv_deadPlayer].lv_respawnTimer) != 0.0) || (TimerGetRemaining(libGDHL_gv_lostVikingsPlayer[lv_deadPlayer].lv_erikDeathTimer) != 0.0) || (TimerGetRemaining(libGDHL_gv_lostVikingsPlayer[lv_deadPlayer].lv_baleogDeathTimer) != 0.0) || (TimerGetRemaining(libGDHL_gv_lostVikingsPlayer[lv_deadPlayer].lv_olafDeathTimer) != 0.0))) {
lv_deadPlayerTeam = libGame_gf_TeamNumberOfPlayer(lv_deadPlayer);
lv_aurielPlayer = 1;
for ( ; ( (autoD32A93E3_ai >= 0 && lv_aurielPlayer <= autoD32A93E3_ae) || (autoD32A93E3_ai < 0 && lv_aurielPlayer >= autoD32A93E3_ae) ) ; lv_aurielPlayer += autoD32A93E3_ai ) {
if ((UnitGetType(libGame_gv_players[lv_aurielPlayer].lv_heroUnit) == "HeroAuriel") && (libGame_gf_TeamNumberOfPlayer(lv_deadPlayer) == libGame_gf_TeamNumberOfPlayer(lv_aurielPlayer)) && (libHAUR_gv_heroAurielResurrectShowSpiritTimer[lv_deadPlayer] == true) && (UnitBehaviorCount(libGame_gv_players[lv_aurielPlayer].lv_heroUnit, "Ultimate1Unlocked") > 0)) {
TextTagDestroy(libHAUR_gv_heroAurielResurrectDeadPlayerSpiritTimerTextTag[lv_deadPlayer][0]);
TextTagDestroy(libHAUR_gv_heroAurielResurrectDeadPlayerSpiritTimerTextTag[lv_deadPlayer][1]);
TextTagDestroy(libHAUR_gv_heroAurielResurrectDeadPlayerSpiritTimerTextTag[lv_deadPlayer][2]);
TextTagDestroy(libHAUR_gv_heroAurielResurrectDeadPlayerSpiritTimerTextTag[lv_deadPlayer][3]);
TextTagDestroy(libHAUR_gv_heroAurielResurrectAurielSpiritTimerTextTag[lv_deadPlayer][0]);
TextTagDestroy(libHAUR_gv_heroAurielResurrectAurielSpiritTimerTextTag[lv_deadPlayer][1]);
TextTagDestroy(libHAUR_gv_heroAurielResurrectAurielSpiritTimerTextTag[lv_deadPlayer][2]);
TextTagDestroy(libHAUR_gv_heroAurielResurrectAurielSpiritTimerTextTag[lv_deadPlayer][3]);
auto1A136385_val = UnitGetType(libGame_gv_players[lv_deadPlayer].lv_heroUnit);
if (auto1A136385_val == "HeroGall") {
if ((TimerGetRemaining(libGame_gv_players[lv_deadPlayer].lv_respawnTimer) > libHAUR_gv_heroAurielResurrectTargetUnresurrectableTime)) {
libHAUR_gv_heroAurielResurrectDeadPlayerSpiritTimerTextTag[lv_deadPlayer][0] = libHAUR_gf_HeroAurielResurrectCreateDeadPlayerSpiritTimer(lv_aurielPlayer, lv_deadPlayer, 0);
}
}
else if (auto1A136385_val == "HeroLostVikingsController") {
if ((TimerGetRemaining(libGDHL_gv_lostVikingsPlayer[lv_deadPlayer].lv_baleogDeathTimer) > libHAUR_gv_heroAurielResurrectTargetUnresurrectableTime) && (libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_deadPlayer][1].lv_spiritUnit != null)) {
TextTagCreate(FixedToText(TimerGetRemaining(libGDHL_gv_lostVikingsPlayer[lv_deadPlayer].lv_baleogDeathTimer), 0), 36, UnitGetPosition(libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_deadPlayer][1].lv_spiritUnit), 4.0, true, false, PlayerGroupSingle(lv_aurielPlayer));
libHAUR_gv_heroAurielResurrectAurielSpiritTimerTextTag[lv_deadPlayer][1] = TextTagLastCreated();
libHAUR_gv_heroAurielResurrectDeadPlayerSpiritTimerTextTag[lv_deadPlayer][1] = libHAUR_gf_HeroAurielResurrectCreateDeadPlayerSpiritTimer(lv_aurielPlayer, lv_deadPlayer, 1);
}
if ((TimerGetRemaining(libGDHL_gv_lostVikingsPlayer[lv_deadPlayer].lv_erikDeathTimer) > libHAUR_gv_heroAurielResurrectTargetUnresurrectableTime) && (libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_deadPlayer][2].lv_spiritUnit != null)) {
TextTagCreate(FixedToText(TimerGetRemaining(libGDHL_gv_lostVikingsPlayer[lv_deadPlayer].lv_erikDeathTimer), 0), 36, UnitGetPosition(libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_deadPlayer][2].lv_spiritUnit), 4.0, true, false, PlayerGroupSingle(lv_aurielPlayer));
libHAUR_gv_heroAurielResurrectAurielSpiritTimerTextTag[lv_deadPlayer][2] = TextTagLastCreated();
libHAUR_gv_heroAurielResurrectDeadPlayerSpiritTimerTextTag[lv_deadPlayer][2] = libHAUR_gf_HeroAurielResurrectCreateDeadPlayerSpiritTimer(lv_aurielPlayer, lv_deadPlayer, 2);
}
if ((TimerGetRemaining(libGDHL_gv_lostVikingsPlayer[lv_deadPlayer].lv_olafDeathTimer) > libHAUR_gv_heroAurielResurrectTargetUnresurrectableTime) && (libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_deadPlayer][3].lv_spiritUnit != null)) {
TextTagCreate(FixedToText(TimerGetRemaining(libGDHL_gv_lostVikingsPlayer[lv_deadPlayer].lv_olafDeathTimer), 0), 36, UnitGetPosition(libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_deadPlayer][3].lv_spiritUnit), 4.0, true, false, PlayerGroupSingle(lv_aurielPlayer));
libHAUR_gv_heroAurielResurrectAurielSpiritTimerTextTag[lv_deadPlayer][3] = TextTagLastCreated();
libHAUR_gv_heroAurielResurrectDeadPlayerSpiritTimerTextTag[lv_deadPlayer][3] = libHAUR_gf_HeroAurielResurrectCreateDeadPlayerSpiritTimer(lv_aurielPlayer, lv_deadPlayer, 3);
}
}
else {
if ((TimerGetRemaining(libGame_gv_players[lv_deadPlayer].lv_respawnTimer) > libHAUR_gv_heroAurielResurrectTargetUnresurrectableTime)) {
}
}
if ((TimerGetRemaining(libGame_gv_players[lv_deadPlayer].lv_respawnTimer) > 4.0) && (TimerGetRemaining(libGame_gv_players[lv_deadPlayer].lv_respawnTimer) < libHAUR_gv_heroAurielResurrectTargetUnresurrectableTime) && (UnitBehaviorCount(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], "AurielResurrectActivelyResurrecting") == 0)) {
if (((UnitGetType(libGame_gv_players[lv_deadPlayer].lv_heroUnit) == "HeroLeoric") || ((UnitGetType(libGame_gv_players[lv_deadPlayer].lv_heroUnit) == "HeroMurky") && (UnitIsAlive(libGame_gv_heroDeathMurkyRespawnEggs[lv_deadPlayer]) == true)))) {
}
else {
libNtve_gf_SendActorMessageToUnit(libHAUR_gv_heroAurielResurrectSpirit[lv_deadPlayer], "Signal Fade");
}
}
if ((UnitGetType(libGame_gv_players[lv_deadPlayer].lv_heroUnit) == "HeroLostVikingsController")) {
if ((TimerGetRemaining(libGDHL_gv_lostVikingsPlayer[lv_deadPlayer].lv_baleogDeathTimer) > 4.0) && (TimerGetRemaining(libGDHL_gv_lostVikingsPlayer[lv_deadPlayer].lv_baleogDeathTimer) < libHAUR_gv_heroAurielResurrectTargetUnresurrectableTime)) {
libNtve_gf_SendActorMessageToUnit(libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_deadPlayer][1].lv_spiritUnit, "Signal Fade");
}
if ((TimerGetRemaining(libGDHL_gv_lostVikingsPlayer[lv_deadPlayer].lv_erikDeathTimer) > 4.0) && (TimerGetRemaining(libGDHL_gv_lostVikingsPlayer[lv_deadPlayer].lv_erikDeathTimer) < libHAUR_gv_heroAurielResurrectTargetUnresurrectableTime)) {
libNtve_gf_SendActorMessageToUnit(libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_deadPlayer][2].lv_spiritUnit, "Signal Fade");
}
if ((TimerGetRemaining(libGDHL_gv_lostVikingsPlayer[lv_deadPlayer].lv_olafDeathTimer) > 4.0) && (TimerGetRemaining(libGDHL_gv_lostVikingsPlayer[lv_deadPlayer].lv_olafDeathTimer) < libHAUR_gv_heroAurielResurrectTargetUnresurrectableTime)) {
libNtve_gf_SendActorMessageToUnit(libHAUR_gv_heroAurielResurrectLostVikingsArray[lv_deadPlayer][3].lv_spiritUnit, "Signal Fade");
}
}
}
}
}
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHAUR_gt_HeroAurielResurrectSpiritTimerController_Init () {
libHAUR_gt_HeroAurielResurrectSpiritTimerController = TriggerCreate("libHAUR_gt_HeroAurielResurrectSpiritTimerController_Func");
TriggerEnable(libHAUR_gt_HeroAurielResurrectSpiritTimerController, false);
TriggerAddEventTimePeriodic(libHAUR_gt_HeroAurielResurrectSpiritTimerController, 0.5, c_timeGame);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Hero - Auriel - Resurrect - End of Game Hide Reviving Dialog
//--------------------------------------------------------------------------------------------------
bool libHAUR_gt_HeroAurielResurrectEndofGameHideRevivingDialog_Func (bool testConds, bool runActions) {
// Automatic Variable Declarations
const int auto00066AEF_ae = libCore_gv_bALMaxPlayers;
int auto00066AEF_var;
// Actions
if (!runActions) {
return true;
}
auto00066AEF_var = 1;
for ( ; auto00066AEF_var <= auto00066AEF_ae; auto00066AEF_var += 1 ) {
if ((libHAUR_gv_heroAurielResurrectRevivingDialog[auto00066AEF_var] != c_invalidDialogId)) {
DialogDestroy(libHAUR_gv_heroAurielResurrectRevivingDialog[auto00066AEF_var]);
}
}
return true;
}
//--------------------------------------------------------------------------------------------------
void libHAUR_gt_HeroAurielResurrectEndofGameHideRevivingDialog_Init () {
libHAUR_gt_HeroAurielResurrectEndofGameHideRevivingDialog = TriggerCreate("libHAUR_gt_HeroAurielResurrectEndofGameHideRevivingDialog_Func");
TriggerEnable(libHAUR_gt_HeroAurielResurrectEndofGameHideRevivingDialog, false);
libGame_gf_GameOverEvent(libHAUR_gt_HeroAurielResurrectEndofGameHideRevivingDialog);
}
void libHAUR_InitTriggers () {
libHAUR_gt_AurielUIInitialize_Init();
libHAUR_gt_HeroAurielShieldofHopeSetShieldStrength_Init();
libHAUR_gt_HeroAurielBestowHopeBestowHopeCast_Init();
libHAUR_gt_HeroAurielBestowHopeSetProxy_Init();
libHAUR_gt_HeroAurielBestowHopeRemoveProxy_Init();
libHAUR_gt_HeroAurielBestowHopeToggleBestowHopeProxyDamageDealtTrigger_Init();
libHAUR_gt_HeroAurielBestowHopeHealingStoredFromProxyDamageDealt_Init();
libHAUR_gt_HeroAurielBestowHopeHealingStoredFromProxyDamageTaken_Init();
libHAUR_gt_HeroAurielBestowHopeProxyUnitSwapped_Init();
libHAUR_gt_HeroAurielRayofHeavenAbilityUsed_Init();
libHAUR_gt_HeroAurielCrystalAegisOverlayController_Init();
libHAUR_gt_HeroAurielResurrectPlayerUnlocksResurrect_Init();
libHAUR_gt_HeroAurielResurrectPlayerRespecs_Init();
libHAUR_gt_HeroAurielResurrectCreateSpirit_Init();
libHAUR_gt_HeroAurielResurrectMurkyEggDeathSpiritReveal_Init();
libHAUR_gt_HeroAurielResurrectLeoricSpiritFollow_Init();
libHAUR_gt_HeroAurielResurrectRevivePlayer_Init();
libHAUR_gt_HeroAurielResurrectPlayerRespawns_Init();
libHAUR_gt_HeroAurielResurrectLostVikingRespawns_Init();
libHAUR_gt_HeroAurielResurrectLostVikingsPlayAgainComplete_Init();
libHAUR_gt_HeroAurielResurrectLostVikingsPlayAgainStart_Init();
libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveStart_Init();
libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveInterrupted_Init();
libHAUR_gt_HeroAurielResurrectNotifyTargetPlayerReviveInterruptedTimerExpired_Init();
libHAUR_gt_HeroAurielResurrectSpiritTimerController_Init();
libHAUR_gt_HeroAurielResurrectEndofGameHideRevivingDialog_Init();
}
//--------------------------------------------------------------------------------------------------
// Library Initialization
//--------------------------------------------------------------------------------------------------
bool libHAUR_InitLib_completed = false;
void libHAUR_InitLib () {
if (libHAUR_InitLib_completed) {
return;
}
libHAUR_InitLib_completed = true;
libHAUR_InitLibraries();
libHAUR_InitVariables();
libHAUR_InitTriggers();
}