include "TriggerLibs/NativeLib"

include "TriggerLibs/GameLib_h"

include "TriggerLibs/MapMechanicsLib_h"

include "TriggerLibs/AILib_h"

include "TriggerLibs/UILib_h"

include "TriggerLibs/StartingExperienceLib_h"

include "TriggerLibs/SoundLib_h"

include "TriggerLibs/GameDataHelperLib_h"

include "TriggerLibs/SupportLib_h"



include "TriggerLibs/HeroesLib_h"



//--------------------------------------------------------------------------------------------------

// Library: Core

//--------------------------------------------------------------------------------------------------

// External Library Initialization

void libCore_InitLibraries () {

    libNtve_InitVariables();

    libGame_InitVariables();

    libMapM_InitVariables();

    libAIAI_InitVariables();

    libUIUI_InitVariables();

    libStEx_InitVariables();

    libSond_InitVariables();

    libGDHL_InitVariables();

    libSprt_InitVariables();

}



// Variable Initialization

bool libCore_InitVariables_completed = false;



void libCore_InitVariables () {

    int init_i;

    int init_i1;



    if (libCore_InitVariables_completed) {

        return;

    }



    libCore_InitVariables_completed = true;



    libCore_gv_dEBUGDebuggingEnabled = GameCheatsEnabled(c_gameCheatCategoryDevelopment);

    libCore_gv_dEBUGDeathRecapEnabled = true;

    libCore_gv_dEBUGPingLimitEnabled = true;

    libCore_gv_sYSGameMode = libCore_ge_GameModes_Normal;

    libCore_gv_sYSStartGame = true;

    libCore_gv_sYSMinionSpawningOn = true;

    libCore_gv_sYSTalentsOn = true;

    libCore_gv_sYSUseEncouragementPanel = true;

    libCore_gv_sYSDataMiningListenForData = true;

    libCore_gv_sYSHeroStartLevel = 1;

    libCore_gv_sYSXPOn = true;

    libCore_gv_mAPMapStringID = "";

    libCore_gv_dataAnnouncerVOExtraAnnouncerEventsIndex = 57;

    for (init_i = 0; init_i <= libCore_gv_dataAnnouncerVOMaxNumberOfAnnouncerEvents; init_i += 1) {

        libCore_gv_dataAnnouncerVODataFieldMap[init_i].lv_vOString = "";

    }

    for (init_i = 0; init_i <= libCore_gv_dataAnnouncerVONumberOfAnnouncerPacks; init_i += 1) {

        libCore_gv_dataAnnouncerVOPacks[init_i].lv_stringName = "";

    }

    libCore_gv_cOLORPlayerColor = Color(0,0,0);

    libCore_gv_cOLORAllyColor = Color(0,0,0);

    libCore_gv_cOLOREnemyColor = Color(0,0,0);

    libCore_gv_cOLORNeutralColor = Color(0,0,0);

    libCore_gv_cOLORJungleCreepColor = Color(0,0,0);

    libCore_gv_bALFaerieDragonFaerieDustHealPercentage = 0.2;

    libCore_gv_bALOpenTheGatesDelay = 35.0;

    libCore_gv_heroes_RandomSkinID = "Random";

    libCore_gv_heroes_RandomMountID = "Random";

    for (init_i = 0; init_i <= libCore_gv_dataHeroVOMaxNumberOfHeroVOEvents; init_i += 1) {

        libCore_gv_dataHeroVODataFieldMap[init_i] = "";

    }

    libCore_gv_bALMinionWaveInterval = 30.0;

    libCore_gv_bALMinionScalingTimerDuration = 60.0;

    for (init_i = 0; init_i <= libCore_gv_dataMinionWaveCompositionMaxCount; init_i += 1) {

        libCore_gv_dataMinionWaveCompositions[init_i].lv_enabled = true;

        for (init_i1 = 0; init_i1 <= libCore_gv_dataMinionWaveCompositionMaxGroupCount; init_i1 += 1) {

            libCore_gv_dataMinionWaveCompositions[init_i].lv_groupMinionType[init_i1] = libCore_ge_MinionTypes_Null;

        }

    }

    libCore_gv_allHeroPlayersPlusObserver = PlayerGroupEmpty();

    libCore_gv_activeHumanPlayers = PlayerGroupEmpty();

    libCore_gv_nPCPlayers = PlayerGroupEmpty();

    for (init_i = 0; init_i <= libCore_gv_bALMaxEnginePlayerCount; init_i += 1) {

        libCore_gv_playerGroupFromPlayer[init_i] = PlayerGroupEmpty();

    }

    libCore_gv_bALCancelDelay = 1.5;

    libCore_gv_bALXPRadius = 12.75;

    libCore_gv_bALHeroKillCreditTimeWindow = 5.0;

    libCore_gv_bALDeathTimeScaler = 1.0;

    libCore_gv_brettTimersDeathModifier = 5.0;

    libCore_gv_brettTimersKillModifier = -1.5;

    libCore_gv_brettTimersTakedownModifier = -0.5;

    libCore_gv_brettTimersMinimumTimer = 5.0;

    libCore_gv_brettTimersMaximumTimer = 65.0;

    libCore_gv_talents_RelentlessCCReduction75_C = 0.75;

    libCore_gv_data_XP_HeroValuePerLevel_C = 50.0;

    for (init_i = 0; init_i <= libCore_gv_bALMaxTeams; init_i += 1) {

        libCore_gv_data_XP_HeroXPModifier[init_i] = 1.0;

    }

    for (init_i = 0; init_i <= libCore_gv_bALMaxTeams; init_i += 1) {

        libCore_gv_data_XP_MinionXPModifier[init_i] = 1.0;

    }

    libCore_gv_data_XP_CatchUpXPBonusScaler = 1.0;

    libCore_gv_data_XP_CatchUpXPPunishmentScaler = 1.0;

    libCore_gv_dataXPBrawlMetaXPExpectedDuration = 15.0;

    libCore_gv_dataXPBrawlMetaXPMaximumDuration = 30.0;

    libCore_gv_metagame_DefaultRotationSlots_C = CatalogFieldValueGetAsInt(c_gameCatalogConfig, "Config", "FreeToPlayHeroBaseCount", c_playerAny);

    libCore_gv_filtersAlly = UnitFilter(0, 0, (1 << c_targetFilterPlayer) | (1 << c_targetFilterNeutral) | (1 << c_targetFilterEnemy) | (1 << c_targetFilterCreep) | (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)));

    libCore_gv_filtersEnemy = UnitFilter(0, 0, (1 << c_targetFilterPlayer) | (1 << c_targetFilterAlly) | (1 << c_targetFilterNeutral) | (1 << c_targetFilterCreep) | (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)));

    libCore_gv_filtersVisible = UnitFilter((1 << c_targetFilterVisible), 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)));

    libCore_gv_filtersNoMinionAggro = UnitFilter((1 << c_targetFilterNoMinionAggro), 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)));

    libCore_gv_filtersIgnoredByTargetingAI = UnitFilter(0, (1 << (c_targetFilterBenign - 32)), (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)));

    libCore_gv_filtersHeroic = UnitFilter((1 << c_targetFilterHeroic), 0, (1 << c_targetFilterMissile) | (1 << c_targetFilterItem), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)));

    libCore_gv_filtersHeroicjustexcludingCloakedandDead = UnitFilter((1 << c_targetFilterHeroic), 0, (1 << c_targetFilterCloaked), (1 << (c_targetFilterDead - 32)));

    libCore_gv_filtersHeroicjustexcludingMissile = UnitFilter((1 << c_targetFilterHeroic), 0, (1 << c_targetFilterMissile), 0);

    libCore_gv_filtersHeroicjustexcludingHallucination = UnitFilter((1 << c_targetFilterHeroic), 0, 0, (1 << (c_targetFilterHallucination - 32)));

    libCore_gv_filtersHeroicAlly = UnitFilter((1 << c_targetFilterHeroic), 0, (1 << c_targetFilterPlayer) | (1 << c_targetFilterNeutral) | (1 << c_targetFilterEnemy) | (1 << c_targetFilterMissile) | (1 << c_targetFilterItem), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)));

    libCore_gv_filtersHeroicAllyandnotHallucination = UnitFilter((1 << c_targetFilterHeroic), 0, (1 << c_targetFilterPlayer) | (1 << c_targetFilterNeutral) | (1 << c_targetFilterEnemy) | (1 << c_targetFilterMissile) | (1 << c_targetFilterItem), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)) | (1 << (c_targetFilterHallucination - 32)));

    libCore_gv_filtersHeroicAllyandnotHallucinationHoverorBenign = UnitFilter((1 << c_targetFilterHeroic), 0, (1 << c_targetFilterPlayer) | (1 << c_targetFilterNeutral) | (1 << c_targetFilterEnemy) | (1 << c_targetFilterImmuneToFriendlyAbilities) | (1 << c_targetFilterMissile) | (1 << c_targetFilterItem), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)) | (1 << (c_targetFilterHallucination - 32)) | (1 << (c_targetFilterBenign - 32)));

    libCore_gv_filtersHeroicAllyandnotImmuneToFriendlyAbilitiesorBenign = UnitFilter((1 << c_targetFilterHeroic), 0, (1 << c_targetFilterPlayer) | (1 << c_targetFilterNeutral) | (1 << c_targetFilterEnemy) | (1 << c_targetFilterImmuneToFriendlyAbilities) | (1 << c_targetFilterMissile) | (1 << c_targetFilterItem), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)) | (1 << (c_targetFilterBenign - 32)));

    libCore_gv_filtersHeroicAllyorPlayer = UnitFilter((1 << c_targetFilterHeroic), 0, (1 << c_targetFilterNeutral) | (1 << c_targetFilterEnemy) | (1 << c_targetFilterMissile) | (1 << c_targetFilterItem), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)));

    libCore_gv_filtersHeroicAllyorPlayerandnotHallucinationorBenign = UnitFilter((1 << c_targetFilterHeroic), 0, (1 << c_targetFilterNeutral) | (1 << c_targetFilterEnemy) | (1 << c_targetFilterMissile) | (1 << c_targetFilterItem), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)) | (1 << (c_targetFilterHallucination - 32)) | (1 << (c_targetFilterBenign - 32)));

    libCore_gv_filtersHeroicAllyorPlayerandnotHover = UnitFilter((1 << c_targetFilterHeroic), 0, (1 << c_targetFilterNeutral) | (1 << c_targetFilterEnemy) | (1 << c_targetFilterImmuneToFriendlyAbilities) | (1 << c_targetFilterMissile) | (1 << c_targetFilterItem), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)));

    libCore_gv_filtersHeroicAllyorPlayerandnotHoverorStasis = UnitFilter((1 << c_targetFilterHeroic), 0, (1 << c_targetFilterNeutral) | (1 << c_targetFilterEnemy) | (1 << c_targetFilterImmuneToFriendlyAbilities) | (1 << c_targetFilterMissile) | (1 << c_targetFilterItem), (1 << (c_targetFilterStasis - 32)) | (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)));

    libCore_gv_filtersHeroicAllyorPlayerandnotStasis = UnitFilter((1 << c_targetFilterHeroic), 0, (1 << c_targetFilterNeutral) | (1 << c_targetFilterEnemy) | (1 << c_targetFilterMissile) | (1 << c_targetFilterItem), (1 << (c_targetFilterStasis - 32)) | (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)));

    libCore_gv_filtersHeroicEnemy = UnitFilter((1 << c_targetFilterHeroic), 0, (1 << c_targetFilterPlayer) | (1 << c_targetFilterAlly) | (1 << c_targetFilterNeutral) | (1 << c_targetFilterMissile) | (1 << c_targetFilterItem), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)));

    libCore_gv_filtersHeroicEnemyorNeutral = UnitFilter((1 << c_targetFilterHeroic), 0, (1 << c_targetFilterPlayer) | (1 << c_targetFilterAlly) | (1 << c_targetFilterMissile) | (1 << c_targetFilterItem), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)));

    libCore_gv_filtersHeroicEnemyandnotHallucination = UnitFilter((1 << c_targetFilterHeroic), 0, (1 << c_targetFilterPlayer) | (1 << c_targetFilterAlly) | (1 << c_targetFilterNeutral) | (1 << c_targetFilterMissile) | (1 << c_targetFilterItem), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)) | (1 << (c_targetFilterHallucination - 32)));

    libCore_gv_filtersHeroicandnotBenign = UnitFilter((1 << c_targetFilterHeroic), 0, (1 << c_targetFilterMissile) | (1 << c_targetFilterItem), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)) | (1 << (c_targetFilterBenign - 32)));

    libCore_gv_filtersHeroicandnotBenignInvulnerableorStasis = UnitFilter((1 << c_targetFilterHeroic), 0, (1 << c_targetFilterMissile) | (1 << c_targetFilterItem), (1 << (c_targetFilterStasis - 32)) | (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)) | (1 << (c_targetFilterInvulnerable - 32)) | (1 << (c_targetFilterBenign - 32)));

    libCore_gv_filtersHeroicandnotCloaked = UnitFilter((1 << c_targetFilterHeroic), 0, (1 << c_targetFilterMissile) | (1 << c_targetFilterItem) | (1 << c_targetFilterCloaked), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)));

    libCore_gv_filtersHeroicandnotHallucination = UnitFilter((1 << c_targetFilterHeroic), 0, (1 << c_targetFilterMissile) | (1 << c_targetFilterItem), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)) | (1 << (c_targetFilterHallucination - 32)));

    libCore_gv_filtersHeroicandnotInvulnerable = UnitFilter((1 << c_targetFilterHeroic), 0, (1 << c_targetFilterMissile) | (1 << c_targetFilterItem), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)) | (1 << (c_targetFilterInvulnerable - 32)));

    libCore_gv_filtersHeroicandnotInvulnerableorStasis = UnitFilter((1 << c_targetFilterHeroic), 0, (1 << c_targetFilterMissile) | (1 << c_targetFilterItem), (1 << (c_targetFilterStasis - 32)) | (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)) | (1 << (c_targetFilterInvulnerable - 32)));

    libCore_gv_filtersHeroicandnotPlayer = UnitFilter((1 << c_targetFilterHeroic), 0, (1 << c_targetFilterPlayer) | (1 << c_targetFilterMissile) | (1 << c_targetFilterItem), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)));

    libCore_gv_filtersHeroicandnotStasis = UnitFilter((1 << c_targetFilterHeroic), 0, (1 << c_targetFilterMissile) | (1 << c_targetFilterItem), (1 << (c_targetFilterStasis - 32)) | (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)));

    libCore_gv_filtersMinionsAllLaners = UnitFilter((1 << c_targetFilterMinion), 0, (1 << c_targetFilterMissile) | (1 << c_targetFilterItem), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)));

    libCore_gv_filtersMinionsTownMinions = UnitFilter((1 << c_targetFilterMinion), 0, (1 << c_targetFilterMerc) | (1 << c_targetFilterMissile) | (1 << c_targetFilterItem), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)) | (1 << (c_targetFilterMapBoss - 32)) | (1 << (c_targetFilterMapCreature - 32)));

    libCore_gv_filtersMercLaner = UnitFilter((1 << c_targetFilterMerc), 0, (1 << c_targetFilterMissile) | (1 << c_targetFilterItem), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)));

    libCore_gv_filtersMercDefender = UnitFilter((1 << c_targetFilterCreep), 0, (1 << c_targetFilterMissile) | (1 << c_targetFilterItem), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)));

    libCore_gv_filtersMapBosses = UnitFilter(0, (1 << (c_targetFilterMapBoss - 32)), (1 << c_targetFilterMissile) | (1 << c_targetFilterItem), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)));

    libCore_gv_filtersMapCreatures = UnitFilter(0, (1 << (c_targetFilterMapCreature - 32)), (1 << c_targetFilterMissile) | (1 << c_targetFilterItem), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)));

    libCore_gv_filtersStructure = UnitFilter((1 << c_targetFilterStructure), 0, (1 << c_targetFilterMissile) | (1 << c_targetFilterItem), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)));

    libCore_gv_filtersSummoned = UnitFilter(0, (1 << (c_targetFilterSummoned - 32)), (1 << c_targetFilterMissile) | (1 << c_targetFilterItem), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)));

    libCore_gv_zS_SendTransmissionCampaignPortrait = c_invalidPortraitId;

    libCore_gv_zS_SendTransmissionCampaignPlayingTick = 3;

    libCore_gv_zS_SendTransmissionCampaignChatBubbleOn = true;

}



// Presets

string libCore_ge_AnnouncerVOEvents_Ident (int lp_val) {

         if (lp_val == libCore_ge_AnnouncerVOEvents_Null) { return "Null"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_GetReadyForBattle) { return "GetReadyForBattle"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_BattleStartingIn) { return "BattleStartingIn"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_Countdown10) { return "Countdown10"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_Countdown5) { return "Countdown5"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_Countdown4) { return "Countdown4"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_Countdown3) { return "Countdown3"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_Countdown2) { return "Countdown2"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_Countdown1) { return "Countdown1"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_LetTheBattleBegin) { return "LetTheBattleBegin"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_YouHaveBeenKilled) { return "YouHaveBeenKilled"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_AllyKilled) { return "AllyKilled"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_EnemyKilledNonparticipants) { return "EnemyKilledNonparticipants"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_EnemyKilledParticipants) { return "EnemyKilledParticipants"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_HeroKilledObserver) { return "HeroKilledObserver"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_DoubleKill) { return "DoubleKill"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_TripleKill) { return "TripleKill"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_QuadraKill) { return "QuadraKill"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_MegaKill) { return "MegaKill"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_SixKill) { return "SixKill"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_SevenKill) { return "SevenKill"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_EightKill) { return "EightKill"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_NineKill) { return "NineKill"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_TenKill) { return "TenKill"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_TeamKill) { return "TeamKill"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_BlueTeamKilled) { return "BlueTeamKilled"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_RedTeamKilled) { return "RedTeamKilled"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_AllyFirstBlood) { return "AllyFirstBlood"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_EnemyFirstBlood) { return "EnemyFirstBlood"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_BlueTeamFirstBlood) { return "BlueTeamFirstBlood"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_RedTeamFirstBlood) { return "RedTeamFirstBlood"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_KillingSpreeStart) { return "KillingSpreeStart"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_KillingSpreeEndYou) { return "KillingSpreeEndYou"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_KillingSpreeUpgrade1Mayhem) { return "KillingSpreeUpgrade1Mayhem"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_KillingSpreeUpgrade2Untouchable) { return "KillingSpreeUpgrade2Untouchable"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_KillingSpreeUpgrade3HeroOfTheStorm) { return "KillingSpreeUpgrade3HeroOfTheStorm"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_KillingSpreeUpgrade4AllStarDEP) { return "KillingSpreeUpgrade4AllStarDEP"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_APlayerHasLeftTheGame) { return "APlayerHasLeftTheGame"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_APlayerHasRejoinedTheGame) { return "APlayerHasRejoinedTheGame"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_GravestoneRevive) { return "GravestoneRevive"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_AlliedOutpostDestroyed) { return "AlliedOutpostDestroyed"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_EnemyOutpostDestroyed) { return "EnemyOutpostDestroyed"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_AlliedKeepDestroyed) { return "AlliedKeepDestroyed"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_EnemyKeepDestroyed) { return "EnemyKeepDestroyed"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_BlueTeamDestroysTown) { return "BlueTeamDestroysTown"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_RedTeamDestroysTown) { return "RedTeamDestroysTown"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_AlliedCoreUnderAttack) { return "AlliedCoreUnderAttack"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_BlueTeamCoreUnderAttack) { return "BlueTeamCoreUnderAttack"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_RedTeamCoreUnderAttack) { return "RedTeamCoreUnderAttack"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_Victory) { return "Victory"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_Defeat) { return "Defeat"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_BlueTeamWins) { return "BlueTeamWins"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_RedTeamWins) { return "RedTeamWins"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_AlliesCaptureMercCamp) { return "AlliesCaptureMercCamp"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_EnemiesCaptureMercCamp) { return "EnemiesCaptureMercCamp"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_BlueTeamCapturesMercCamp) { return "BlueTeamCapturesMercCamp"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_RedTeamCapturesMercCamp) { return "RedTeamCapturesMercCamp"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_LevelUp) { return "LevelUp"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_TalentUnlocked) { return "TalentUnlocked"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_EventCount) { return "EventCount"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_GamePaused) { return "GamePaused"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_GameResumed) { return "GameResumed"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_MVP) { return "MVP"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_MVPVoteEpic) { return "MVPVoteEpic"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_MVPVoteLegendary) { return "MVPVoteLegendary"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_Preset65) { return "Preset65"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_Preset66) { return "Preset66"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_Preset67) { return "Preset67"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_Preset68) { return "Preset68"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_Preset69) { return "Preset69"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_Preset70) { return "Preset70"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_Preset71) { return "Preset71"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_Preset72) { return "Preset72"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_Preset73) { return "Preset73"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_Preset74) { return "Preset74"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_Preset75) { return "Preset75"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_Preset76) { return "Preset76"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_Preset77) { return "Preset77"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_Preset78) { return "Preset78"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_Preset79) { return "Preset79"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_Preset80) { return "Preset80"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_Preset81) { return "Preset81"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_Preset82) { return "Preset82"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_Preset83) { return "Preset83"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_Preset84) { return "Preset84"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_Preset85) { return "Preset85"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_Preset86) { return "Preset86"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_Preset87) { return "Preset87"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_Preset88) { return "Preset88"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_Preset89) { return "Preset89"; }

    else if (lp_val == libCore_ge_AnnouncerVOEvents_Preset90) { return "Preset90"; }

    return null;

}



string libCore_ge_SegregationTriggerTypes_Ident (int lp_val) {

         if (lp_val == libCore_ge_SegregationTriggerTypes_DefenderAIIssueOrdersToCreep) { return "DefenderAIIssueOrdersToCreep"; }

    else if (lp_val == libCore_ge_SegregationTriggerTypes_HeroAIInitializeHeroTierData) { return "HeroAIInitializeHeroTierData"; }

    else if (lp_val == libCore_ge_SegregationTriggerTypes_HeroAIInitAbilities) { return "HeroAIInitAbilities"; }

    else if (lp_val == libCore_ge_SegregationTriggerTypes_HeroAIEnableAIForPlayer) { return "HeroAIEnableAIForPlayer"; }

    else if (lp_val == libCore_ge_SegregationTriggerTypes_HeroAIDebuggingUpdateStatus) { return "HeroAIDebuggingUpdateStatus"; }

    else if (lp_val == libCore_ge_SegregationTriggerTypes_HeroAIMapMechanicPinged) { return "HeroAIMapMechanicPinged"; }

    else if (lp_val == libCore_ge_SegregationTriggerTypes_HeroAIFollowerNearbyMapObjective) { return "HeroAIFollowerNearbyMapObjective"; }

    else if (lp_val == libCore_ge_SegregationTriggerTypes_HeroAITalentLogic) { return "HeroAITalentLogic"; }

    else if (lp_val == libCore_ge_SegregationTriggerTypes_HeroAIIsCurrentlyAttacking) { return "HeroAIIsCurrentlyAttacking"; }

    return null;

}



// Functions

int libCore_gf_CustomValueIndex (int lp_indexName) {

    // Automatic Variable Declarations

    // Implementation

    return (lp_indexName);

}



void libCore_gf_DataAnnouncerVOMapDataField (int lp_event, string lp_arrayIndexName, bool lp_playAtGameEnd) {

    // Automatic Variable Declarations

    // Implementation

    if ((lp_arrayIndexName == "")) {

        libCore_gv_dataAnnouncerVODataFieldMap[(lp_event)].lv_vOString = "";

    }

    else {

        libCore_gv_dataAnnouncerVODataFieldMap[(lp_event)].lv_vOString = lp_arrayIndexName;

    }

    libCore_gv_dataAnnouncerVODataFieldMap[(lp_event)].lv_playAtGameEnd = lp_playAtGameEnd;

}



int libCore_gf_DataAnnouncerVOAddOutsideMapDataField (string lp_soundString, bool lp_playAtGameEnd) {

    // Variable Declarations

    int lv_presetValue;



    // Automatic Variable Declarations

    // Variable Initialization



    // Implementation

    libCore_gv_dataAnnouncerVOExtraAnnouncerEventsIndex += 1;

    if ((libCore_gv_dataAnnouncerVOExtraAnnouncerEventsIndex > libCore_gv_dataAnnouncerVOMaxNumberOfAnnouncerEvents)) {

        TextExpressionSetToken("Param/Expression/lib_Core_9E884F52", "A", StringToText(lp_soundString));

        TextExpressionSetToken("Param/Expression/lib_Core_9E884F52", "B", IntToText(libCore_gv_dataAnnouncerVOExtraAnnouncerEventsIndex));

        TextExpressionSetToken("Param/Expression/lib_Core_9E884F52", "C", IntToText(libCore_gv_dataAnnouncerVOMaxNumberOfAnnouncerEvents));

        TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Core_9E884F52"), true);

        return libCore_ge_AnnouncerVOEvents_Null;

    }



    lv_presetValue = libCore_gv_dataAnnouncerVOExtraAnnouncerEventsIndex;

    libCore_gv_dataAnnouncerVODataFieldMap[libCore_gv_dataAnnouncerVOExtraAnnouncerEventsIndex].lv_vOString = lp_soundString;

    libCore_gv_dataAnnouncerVODataFieldMap[libCore_gv_dataAnnouncerVOExtraAnnouncerEventsIndex].lv_playAtGameEnd = lp_playAtGameEnd;

    return lv_presetValue;

}



void libCore_gf_DataInitializeAnnouncerVOPackSingle (int lp_iDPack, string lp_stringID, text lp_name) {

    // Variable Declarations

    int lv_itEvent;

    string lv_dataFieldMapString;

    string lv_soundID;



    // Automatic Variable Declarations

    const int autoEFD0FA2B_ae = libCore_gv_dataAnnouncerVOMaxNumberOfAnnouncerEvents;

    const int autoEFD0FA2B_ai = 1;



    // Variable Initialization

    lv_dataFieldMapString = "";



    // Implementation

    libCore_gv_dataAnnouncerVOPacks[lp_iDPack].lv_name = lp_name;

    libCore_gv_dataAnnouncerVOPacks[lp_iDPack].lv_stringName = lp_stringID;

    lv_itEvent = 1;

    for ( ; ( (autoEFD0FA2B_ai >= 0 && lv_itEvent <= autoEFD0FA2B_ae) || (autoEFD0FA2B_ai < 0 && lv_itEvent >= autoEFD0FA2B_ae) ) ; lv_itEvent += autoEFD0FA2B_ai ) {

        lv_dataFieldMapString = libCore_gv_dataAnnouncerVODataFieldMap[lv_itEvent].lv_vOString;

        if ((lv_dataFieldMapString == "")) {

            TextExpressionSetToken("Param/Expression/lib_Core_073199C2", "A", IntToText(lv_itEvent));

            TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Core_073199C2"), false);

            continue;

        }



        lv_soundID = ((libCore_gv_dataAnnouncerVOPacks[lp_iDPack].lv_stringName + "_" + lv_dataFieldMapString));

        if ((CatalogEntryIsValid(c_gameCatalogSound, lv_soundID) == true)) {

            libCore_gv_dataAnnouncerVOPacks[lp_iDPack].lv_announcerVOLines[lv_itEvent].lv_soundLink = lv_soundID;

            libCore_gv_dataAnnouncerVOPacks[lp_iDPack].lv_announcerVOLines[lv_itEvent].lv_playAtGameEnd = libCore_gv_dataAnnouncerVODataFieldMap[lv_itEvent].lv_playAtGameEnd;

        }



    }

}



void libCore_gf_DataAnnouncerVOSetAnnouncerPackForPlayerGroup (playergroup lp_playerGroup, int lp_announcerPack) {

    // Variable Declarations

    int lv_itPlayer;



    // Automatic Variable Declarations

    playergroup auto693BAA6F_g;



    // Variable Initialization



    // Implementation

    auto693BAA6F_g = lp_playerGroup;

    lv_itPlayer = -1;

    while (true) {

        	lv_itPlayer = PlayerGroupNextPlayer(auto693BAA6F_g, lv_itPlayer);

        	if (lv_itPlayer<0) { break; }

        	libGame_gv_players[lv_itPlayer].lv_selectedAnnouncerVOPack = lp_announcerPack;

    }

}



void libCore_gf_DataAnnouncerVOSetDefaultAnnouncerForPlayerGroup (playergroup lp_playerGroup, string lp_announcerPackLink) {

    // Variable Declarations

    int lv_itPlayer;



    // Automatic Variable Declarations

    playergroup autoB6CAB221_g;



    // Variable Initialization



    // Implementation

    autoB6CAB221_g = lp_playerGroup;

    lv_itPlayer = -1;

    while (true) {

        	lv_itPlayer = PlayerGroupNextPlayer(autoB6CAB221_g, lv_itPlayer);

        	if (lv_itPlayer<0) { break; }

        	if ((libGame_gv_players[lv_itPlayer].lv_lootContent.lv_loot_AnnouncerPack.lv_announcerIsPlayerAssigned == false)) {

            libCore_gf_DataLootContentLoadAnnouncerPackDataIntoIndex(lp_announcerPackLink, lv_itPlayer, false);

        }



    }

}



void libCore_gf_UpdateTassadarAbilityStats (unit lp_tassadar) {

    // Variable Declarations

    int lv_player;

    fixed lv_basePeriod;

    fixed lv_multiplier;

    fixed lv_finalPeriod;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_player = UnitGetOwner(lp_tassadar);

    lv_basePeriod = CatalogFieldValueGetAsFixed(c_gameCatalogWeapon, "TassadarResonanceBeam", "Period", 0);

    lv_multiplier = libCore_gf_GetWeaponAttackSpeedForUnit(lp_tassadar);

    lv_finalPeriod = (lv_multiplier * lv_basePeriod);



    // Implementation

    if ((lv_finalPeriod != 0.0)) {

        CatalogFieldValueSetFixed(c_gameCatalogEffect, "TassadarResonanceBeamCreatePersistent", "PeriodicPeriodArray[" + IntToString(0) + "]", lv_player, lv_finalPeriod);

        CatalogFieldValueSetFixed(c_gameCatalogEffect, "TassadarResonanceBeamKhaydarinAmuletTalentSearch1CreatePersistent", "PeriodicPeriodArray[" + IntToString(0) + "]", lv_player, lv_finalPeriod);

        CatalogFieldValueSetFixed(c_gameCatalogEffect, "TassadarResonanceBeamKhaydarinAmuletTalentSearch2CreatePersistent", "PeriodicPeriodArray[" + IntToString(0) + "]", lv_player, lv_finalPeriod);

        CatalogFieldValueSetFixed(c_gameCatalogEffect, "TassadarResonanceBeamKhaydarinAmuletRevealTarget", "Duration", lv_player, (lv_finalPeriod + 0.0625));

    }



}



void libCore_gf_DataHeroesAddManualSpawnHero (int lp_heroID, bool lp_isAttachedHero, bool lp_isCoreHero) {

    // Variable Declarations

    int lv_index;



    // Automatic Variable Declarations

    const int auto6934A357_ae = libCore_gv_dataHeroesManualSpawnHeroesCount;

    const int auto6934A357_ai = 1;



    // Variable Initialization



    // Implementation

    lv_index = 1;

    for ( ; ( (auto6934A357_ai >= 0 && lv_index <= auto6934A357_ae) || (auto6934A357_ai < 0 && lv_index >= auto6934A357_ae) ) ; lv_index += auto6934A357_ai ) {

        if ((libCore_gv_dataHeroesManualSpawnHeroIDs[lv_index].lv_heroIndex == 0)) {

            libCore_gv_dataHeroesManualSpawnHeroIDs[lv_index].lv_heroIndex = lp_heroID;

            libCore_gv_dataHeroesManualSpawnHeroIDs[lv_index].lv_attached = lp_isAttachedHero;

            libCore_gv_dataHeroesManualSpawnHeroIDs[lv_index].lv_core = lp_isCoreHero;

            return ;

        }



        if ((libCore_gv_dataHeroesManualSpawnHeroIDs[lv_index].lv_heroIndex == lp_heroID)) {

            return ;

        }



    }

    TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Core_FF6BF923"), true);

}



int libCore_gf_GetHeroTotalCount () {

    // Automatic Variable Declarations

    // Implementation

    return CatalogFieldValueCount(c_gameCatalogConfig, "Config", "HeroArray", 1);

}



string libCore_gf_GetHeroFromUnitType (string lp_unitType) {

    // Variable Declarations

    int lv_itHero;

    int lv_itAlternateUnit;

    string lv_hero;



    // Automatic Variable Declarations

    int autoE6EACDD0_ae;

    const int autoE6EACDD0_ai = 1;

    int auto59E87D74_ae;

    const int auto59E87D74_ai = 1;



    // Variable Initialization



    // Implementation

    autoE6EACDD0_ae = libCore_gf_GetHeroTotalCount();

    lv_itHero = 1;

    for ( ; ( (autoE6EACDD0_ai >= 0 && lv_itHero <= autoE6EACDD0_ae) || (autoE6EACDD0_ai < 0 && lv_itHero >= autoE6EACDD0_ae) ) ; lv_itHero += autoE6EACDD0_ai ) {

        lv_hero = libCore_gf_GetHeroFromIndex(lv_itHero);

        if (((CatalogFieldValueGet(c_gameCatalogHero, lv_hero, "Unit", c_playerAny)) == lp_unitType)) {

            return lv_hero;

        }



        auto59E87D74_ae = CatalogFieldValueCount(c_gameCatalogHero, lv_hero, "AlternateUnitArray", c_playerAny);

        lv_itAlternateUnit = 1;

        for ( ; ( (auto59E87D74_ai >= 0 && lv_itAlternateUnit <= auto59E87D74_ae) || (auto59E87D74_ai < 0 && lv_itAlternateUnit >= auto59E87D74_ae) ) ; lv_itAlternateUnit += auto59E87D74_ai ) {

            if (((CatalogFieldValueGet(c_gameCatalogHero, lv_hero, "AlternateUnitArray[" + IntToString((lv_itAlternateUnit - 1)) + "]", c_playerAny)) == lp_unitType)) {

                return lv_hero;

            }



        }

    }

    return null;

}



string libCore_gf_GetHeroFromIndex (int lp_index) {

    // Variable Declarations

    string lv_value;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_value = "";



    // Implementation

    lv_value = CatalogFieldValueGet(c_gameCatalogConfig, "Config", "HeroArray[" + IntToString((lp_index - 1)) + "]", 1);

    return (lv_value);

}



int libCore_gf_GetIndexFromHero (string lp_hero) {

    // Variable Declarations

    int lv_index;



    // Automatic Variable Declarations

    int auto526BD385_ae;

    const int auto526BD385_ai = 1;



    // Variable Initialization



    // Implementation

    auto526BD385_ae = libCore_gf_GetHeroTotalCount();

    lv_index = 1;

    for ( ; ( (auto526BD385_ai >= 0 && lv_index <= auto526BD385_ae) || (auto526BD385_ai < 0 && lv_index >= auto526BD385_ae) ) ; lv_index += auto526BD385_ai ) {

        if ((libCore_gf_GetHeroFromIndex(lv_index) == lp_hero)) {

            return lv_index;

        }



    }

    return 0;

}



void libCore_gf_DataHeroesAddSkinPlusVariationsToHero (int lp_heroIndex, string lp_skinLink) {

    // Variable Declarations

    int lv_itVariation;



    // Automatic Variable Declarations

    int auto5ED658DB_ae;

    const int auto5ED658DB_ai = 1;



    // Variable Initialization



    // Implementation

    libGame_gv_players[lp_heroIndex].lv_heroData.lv_skinCount += 1;

    if ((libGame_gv_players[lp_heroIndex].lv_heroData.lv_skinCount > libCore_gv_heroes_MaxSkinsPerHero_C)) {

        libGame_gv_players[lp_heroIndex].lv_heroData.lv_skinCount -= 1;

        TextExpressionSetToken("Param/Expression/lib_Core_B0BBDB45", "A", StringToText((libGame_gv_players[lp_heroIndex].lv_heroData.lv_heroCatalogLink)));

        TextExpressionSetToken("Param/Expression/lib_Core_B0BBDB45", "B", IntToText(libCore_gv_heroes_MaxSkinsPerHero_C));

        TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Core_B0BBDB45"), true);

        return ;

    }



    libGame_gv_players[lp_heroIndex].lv_heroData.lv_skinArray[libGame_gv_players[lp_heroIndex].lv_heroData.lv_skinCount] = lp_skinLink;

    auto5ED658DB_ae = (CatalogFieldValueCount(c_gameCatalogSkin, lp_skinLink, "VariationArray", c_playerAny) - 1);

    lv_itVariation = 0;

    for ( ; ( (auto5ED658DB_ai >= 0 && lv_itVariation <= auto5ED658DB_ae) || (auto5ED658DB_ai < 0 && lv_itVariation >= auto5ED658DB_ae) ) ; lv_itVariation += auto5ED658DB_ai ) {

        libCore_gf_DataHeroesAddSkinPlusVariationsToHero(lp_heroIndex, (CatalogFieldValueGet(c_gameCatalogSkin, lp_skinLink, "VariationArray[" + IntToString(lv_itVariation) + "]", c_playerAny)));

    }

}



void libCore_gf_DataHeroesAddHeroSkinIDToDataTable (int lp_heroIndex, string lp_skinLink) {

    // Variable Declarations

    int lv_itVariation;

    int lv_newSkinCount;



    // Automatic Variable Declarations

    int autoEC162BB4_ae;

    const int autoEC162BB4_ai = 1;



    // Variable Initialization



    // Implementation

    lv_newSkinCount = (DataTableGetInt(true, ("HeroIndex_" + IntToString(lp_heroIndex) + "_SkinCount")) + 1);

    DataTableSetInt(true, ("HeroIndex_" + IntToString(lp_heroIndex) + "_SkinCount"), lv_newSkinCount);

    DataTableSetString(true, ("HeroIndex_" + IntToString(lp_heroIndex) + "_SkinIndex_" + IntToString(lv_newSkinCount)), (lp_skinLink));

    autoEC162BB4_ae = (CatalogFieldValueCount(c_gameCatalogSkin, lp_skinLink, "VariationArray", c_playerAny) - 1);

    lv_itVariation = 0;

    for ( ; ( (autoEC162BB4_ai >= 0 && lv_itVariation <= autoEC162BB4_ae) || (autoEC162BB4_ai < 0 && lv_itVariation >= autoEC162BB4_ae) ) ; lv_itVariation += autoEC162BB4_ai ) {

        libCore_gf_DataHeroesAddHeroSkinIDToDataTable(lp_heroIndex, (CatalogFieldValueGet(c_gameCatalogSkin, lp_skinLink, "VariationArray[" + IntToString(lv_itVariation) + "]", c_playerAny)));

    }

}



void libCore_gf_DataHeroesAddHeroIDToDataTable (int lp_heroIndex, string lp_heroLink) {

    // Variable Declarations

    string lv_heroID;

    string lv_skinID;

    string lv_mountCategoryID;

    string lv_mountCategoryCountStr;

    string lv_heroIndexStr;

    int lv_itSkin;

    int lv_itMountCategory;

    int lv_itSkinAddedMountCategory;

    int lv_itVoiceLine;

    string lv_voiceLineID;

    string lv_voiceLineCountStr;



    // Automatic Variable Declarations

    int auto5C57F1C1_ae;

    const int auto5C57F1C1_ai = 1;

    int auto938DD68A_ae;

    const int auto938DD68A_ai = 1;

    int autoA7E35B1D_ae;

    const int autoA7E35B1D_ai = 1;

    int auto2E6C8612_ae;

    const int auto2E6C8612_ai = 1;

    int autoF024766A_ae;

    const int autoF024766A_ai = 1;



    // Variable Initialization

    lv_heroID = "";

    lv_skinID = "";

    lv_mountCategoryID = "";

    lv_mountCategoryCountStr = "";

    lv_heroIndexStr = "";

    lv_voiceLineID = "";

    lv_voiceLineCountStr = "";



    // Implementation

    lv_heroID = (lp_heroLink);

    lv_heroIndexStr = IntToString(lp_heroIndex);

    lv_mountCategoryCountStr = ("HeroIndex_" + lv_heroIndexStr + "_MountCategoryCount");

    lv_voiceLineCountStr = ("HeroIndex_" + lv_heroIndexStr + "_VoiceLineCount");

    DataTableSetString(true, ("HeroIndex_" + lv_heroIndexStr), lv_heroID);

    DataTableSetInt(true, ("HeroIndex_" + IntToString(lp_heroIndex) + "_MountCategoryCount"), 0);

    auto5C57F1C1_ae = CatalogFieldValueCount(c_gameCatalogHero, lv_heroID, "AllowedMountCategoryArray", c_playerAny);

    lv_itMountCategory = 1;

    for ( ; ( (auto5C57F1C1_ai >= 0 && lv_itMountCategory <= auto5C57F1C1_ae) || (auto5C57F1C1_ai < 0 && lv_itMountCategory >= auto5C57F1C1_ae) ) ; lv_itMountCategory += auto5C57F1C1_ai ) {

        lv_mountCategoryID = CatalogFieldValueGet(c_gameCatalogHero, lv_heroID, "AllowedMountCategoryArray[" + IntToString((lv_itMountCategory - 1)) + "]", c_playerAny);

        DataTableSetInt(true, lv_mountCategoryCountStr, (DataTableGetInt(true, lv_mountCategoryCountStr) + 1));

        DataTableSetString(true, ("HeroIndex_" + lv_heroIndexStr + "_MountCategoryIndex_" + IntToString(DataTableGetInt(true, lv_mountCategoryCountStr))), lv_mountCategoryID);

        DataTableSetBool(true, ("HeroIndex_" + lv_heroIndexStr + "_MountCategoryIndex_" + IntToString(DataTableGetInt(true, lv_mountCategoryCountStr)) + "_GrantedBySkin"), false);

    }

    DataTableSetString(true, ("HeroIndex_" + lv_heroIndexStr + "_SkinIndex_" + IntToString(1)), "Default");

    DataTableSetInt(true, ("HeroIndex_" + lv_heroIndexStr + "_SkinCount"), 1);

    auto938DD68A_ae = (CatalogFieldValueCount(c_gameCatalogHero, lv_heroID, "SkinArray", c_playerAny) - 1);

    lv_itSkin = 0;

    for ( ; ( (auto938DD68A_ai >= 0 && lv_itSkin <= auto938DD68A_ae) || (auto938DD68A_ai < 0 && lv_itSkin >= auto938DD68A_ae) ) ; lv_itSkin += auto938DD68A_ai ) {

        lv_skinID = CatalogFieldValueGet(c_gameCatalogHero, lv_heroID, "SkinArray[" + IntToString(lv_itSkin) + "]", c_playerAny);

        libCore_gf_DataHeroesAddHeroSkinIDToDataTable(lp_heroIndex, (lv_skinID));

        autoA7E35B1D_ae = CatalogFieldValueCount(c_gameCatalogSkin, (lv_skinID), "AdditionalMountCategoryArray", c_playerAny);

        lv_itSkinAddedMountCategory = 1;

        for ( ; ( (autoA7E35B1D_ai >= 0 && lv_itSkinAddedMountCategory <= autoA7E35B1D_ae) || (autoA7E35B1D_ai < 0 && lv_itSkinAddedMountCategory >= autoA7E35B1D_ae) ) ; lv_itSkinAddedMountCategory += autoA7E35B1D_ai ) {

            lv_mountCategoryID = CatalogFieldValueGet(c_gameCatalogSkin, lv_skinID, "AdditionalMountCategoryArray[" + IntToString((lv_itSkinAddedMountCategory - 1)) + "]", c_playerAny);

            DataTableSetInt(true, lv_mountCategoryCountStr, (DataTableGetInt(true, lv_mountCategoryCountStr) + 1));

            DataTableSetString(true, ("HeroIndex_" + lv_heroIndexStr + "_MountCategoryIndex_" + IntToString(DataTableGetInt(true, lv_mountCategoryCountStr))), lv_mountCategoryID);

            DataTableSetBool(true, ("HeroIndex_" + lv_heroIndexStr + "_MountCategoryIndex_" + IntToString(DataTableGetInt(true, lv_mountCategoryCountStr)) + "_GrantedBySkin"), true);

        }

    }

    auto2E6C8612_ae = (CatalogFieldValueCount(c_gameCatalogHero, lv_heroID, "VariationArray", c_playerAny) - 1);

    lv_itSkin = 0;

    for ( ; ( (auto2E6C8612_ai >= 0 && lv_itSkin <= auto2E6C8612_ae) || (auto2E6C8612_ai < 0 && lv_itSkin >= auto2E6C8612_ae) ) ; lv_itSkin += auto2E6C8612_ai ) {

        libCore_gf_DataHeroesAddHeroSkinIDToDataTable(lp_heroIndex, (CatalogFieldValueGet(c_gameCatalogHero, lv_heroID, "VariationArray[" + IntToString(lv_itSkin) + "]", c_playerAny)));

    }

    DataTableSetInt(true, lv_voiceLineCountStr, 0);

    autoF024766A_ae = CatalogFieldValueCount(c_gameCatalogHero, lv_heroID, "VoiceLineArray", c_playerAny);

    lv_itVoiceLine = 1;

    for ( ; ( (autoF024766A_ai >= 0 && lv_itVoiceLine <= autoF024766A_ae) || (autoF024766A_ai < 0 && lv_itVoiceLine >= autoF024766A_ae) ) ; lv_itVoiceLine += autoF024766A_ai ) {

        lv_voiceLineID = CatalogFieldValueGet(c_gameCatalogHero, lv_heroID, "VoiceLineArray[" + IntToString((lv_itVoiceLine - 1)) + "]", c_playerAny);

        if ((lv_voiceLineID != ("RandomVoiceLine"))) {

            DataTableSetInt(true, lv_voiceLineCountStr, (DataTableGetInt(true, lv_voiceLineCountStr) + 1));

            DataTableSetString(true, ("HeroIndex_" + lv_heroIndexStr + "_VoiceLineIndex_" + IntToString(DataTableGetInt(true, lv_voiceLineCountStr))), lv_voiceLineID);

        }



    }

}



void libCore_gf_DataClearHeroDataAtIndex (int lp_index) {

    // Variable Declarations

    string lv_heroID;

    string lv_unitType;

    int lv_classInt;

    int lv_universeInt;

    int lv_genderInt;

    int lv_requiredRewardCount;

    int lv_introCutsceneSizeInt;

    int lv_numberOfLevelUpAbils;

    int lv_numberOfLevelUpAbilMods;

    int lv_catalogInt;

    int lv_itAbility;

    int lv_itLevelUpAbility;

    int lv_itLevelUpAbilityMod;

    int lv_itPlayerIndex;

    int lv_itRequiredReward;

    int lv_itSkin;

    int lv_itMountCategory;

    int lv_itAlternateHero;



    // Automatic Variable Declarations

    const int autoEE4A5A86_ae = libCore_gv_data_MaxRequiredRewards_C;

    const int autoEE4A5A86_ai = 1;

    const int autoF0428C63_ae = libCore_gv_dataHeroesMaxAlternateHeroes;

    const int autoF0428C63_ai = 1;

    int auto3BD4B1AE_ae;

    const int auto3BD4B1AE_ai = 1;

    const int autoEF8238A5_ae = libCore_gv_dataHeroesMaxAbilitiesPerHero;

    const int autoEF8238A5_ai = 1;

    const int autoA18BD661_ae = libCore_gv_dataMaxCatalogChangesPerAbility;

    const int autoA18BD661_ai = 1;

    const int auto95B84E4E_ae = libCore_gv_data_MaxHeroAllowedMountCategories_C;

    const int auto95B84E4E_ai = 1;

    int auto24AE07AB_ae;

    const int auto24AE07AB_ai = 1;



    // Variable Initialization

    lv_heroID = "";



    // Implementation

    if ((lp_index <= 0)) {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Core_FED2A921"), true);

        return ;

    }



    lv_itPlayerIndex = lp_index;

    lv_itRequiredReward = 1;

    for ( ; ( (autoEE4A5A86_ai >= 0 && lv_itRequiredReward <= autoEE4A5A86_ae) || (autoEE4A5A86_ai < 0 && lv_itRequiredReward >= autoEE4A5A86_ae) ) ; lv_itRequiredReward += autoEE4A5A86_ai ) {

        libGame_gv_players[lv_itPlayerIndex].lv_heroData.lv_requiredRewardArray[lv_itRequiredReward] = null;

    }

    lv_itAlternateHero = 1;

    for ( ; ( (autoF0428C63_ai >= 0 && lv_itAlternateHero <= autoF0428C63_ae) || (autoF0428C63_ai < 0 && lv_itAlternateHero >= autoF0428C63_ae) ) ; lv_itAlternateHero += autoF0428C63_ai ) {

        libGame_gv_players[lv_itPlayerIndex].lv_heroData.lv_alternateUnitTypes[lv_itAlternateHero] = null;

    }

    libGame_gv_players[lv_itPlayerIndex].lv_heroData.lv_numberOfAbilities = libCore_gv_dataHeroesMaxAbilitiesPerHero;

    auto3BD4B1AE_ae = libGame_gv_players[lv_itPlayerIndex].lv_heroData.lv_numberOfAbilities;

    lv_itAbility = 1;

    for ( ; ( (auto3BD4B1AE_ai >= 0 && lv_itAbility <= auto3BD4B1AE_ae) || (auto3BD4B1AE_ai < 0 && lv_itAbility >= auto3BD4B1AE_ae) ) ; lv_itAbility += auto3BD4B1AE_ai ) {

        libGame_gv_players[lv_itPlayerIndex].lv_heroData.lv_abilities[lv_itAbility].lv_ability = null;

        libGame_gv_players[lv_itPlayerIndex].lv_heroData.lv_abilities[lv_itAbility].lv_isAffectedByCooldownReduction = false;

        libGame_gv_players[lv_itPlayerIndex].lv_heroData.lv_abilities[lv_itAbility].lv_isHeroic = false;

        libGame_gv_players[lv_itPlayerIndex].lv_heroData.lv_abilities[lv_itAbility].lv_isTrait = false;

        libGame_gv_players[lv_itPlayerIndex].lv_heroData.lv_abilities[lv_itAbility].lv_usesCharges = false;

        libGame_gv_players[lv_itPlayerIndex].lv_heroData.lv_abilities[lv_itAbility].lv_isAffectedByOverdrive = false;

        libGame_gv_players[lv_itPlayerIndex].lv_heroData.lv_abilities[lv_itAbility].lv_isMountReplacement = false;

    }

    lv_itLevelUpAbility = 1;

    for ( ; ( (autoEF8238A5_ai >= 0 && lv_itLevelUpAbility <= autoEF8238A5_ae) || (autoEF8238A5_ai < 0 && lv_itLevelUpAbility >= autoEF8238A5_ae) ) ; lv_itLevelUpAbility += autoEF8238A5_ai ) {

        lv_numberOfLevelUpAbilMods = 0;

        libGame_gv_players[lv_itPlayerIndex].lv_heroData.lv_levelUpModificationData.lv_numberOfFieldChanges[lv_itLevelUpAbility] = 0;

        lv_itLevelUpAbilityMod = 1;

        for ( ; ( (autoA18BD661_ai >= 0 && lv_itLevelUpAbilityMod <= autoA18BD661_ae) || (autoA18BD661_ai < 0 && lv_itLevelUpAbilityMod >= autoA18BD661_ae) ) ; lv_itLevelUpAbilityMod += autoA18BD661_ai ) {

            libGame_gv_players[lv_itPlayerIndex].lv_heroData.lv_levelUpModificationData.lv_affectedByAbilityPower[lv_itLevelUpAbility][lv_itLevelUpAbilityMod] = false;

            libGame_gv_players[lv_itPlayerIndex].lv_heroData.lv_levelUpModificationData.lv_percentScaled[lv_itLevelUpAbility][lv_itLevelUpAbilityMod] = false;

            libGame_gv_players[lv_itPlayerIndex].lv_heroData.lv_levelUpModificationData.lv_catalog[lv_itLevelUpAbility][lv_itLevelUpAbilityMod] = c_gameCatalogUnit;

            libGame_gv_players[lv_itPlayerIndex].lv_heroData.lv_levelUpModificationData.lv_entry[lv_itLevelUpAbility][lv_itLevelUpAbilityMod] = "";

            libGame_gv_players[lv_itPlayerIndex].lv_heroData.lv_levelUpModificationData.lv_field[lv_itLevelUpAbility][lv_itLevelUpAbilityMod] = "";

            libGame_gv_players[lv_itPlayerIndex].lv_heroData.lv_levelUpModificationData.lv_fieldIsInteger[lv_itLevelUpAbility][lv_itLevelUpAbilityMod] = false;

            libGame_gv_players[lv_itPlayerIndex].lv_heroData.lv_levelUpModificationData.lv_valueAddedPerLevel[lv_itLevelUpAbility][lv_itLevelUpAbilityMod] = 0.0;

        }

    }

    libGame_gv_players[lv_itPlayerIndex].lv_heroData.lv_usesMounts = false;

    libGame_gv_players[lv_itPlayerIndex].lv_heroData.lv_allowedMountCategoryCount = 0;

    lv_itMountCategory = 1;

    for ( ; ( (auto95B84E4E_ai >= 0 && lv_itMountCategory <= auto95B84E4E_ae) || (auto95B84E4E_ai < 0 && lv_itMountCategory >= auto95B84E4E_ae) ) ; lv_itMountCategory += auto95B84E4E_ai ) {

        libGame_gv_players[lv_itPlayerIndex].lv_heroData.lv_allowedMountCategories[lv_itMountCategory] = "";

    }

    libGame_gv_players[lv_itPlayerIndex].lv_heroData.lv_defaultMount = null;

    auto24AE07AB_ae = libGame_gv_players[lv_itPlayerIndex].lv_heroData.lv_skinCount;

    lv_itSkin = 1;

    for ( ; ( (auto24AE07AB_ai >= 0 && lv_itSkin <= auto24AE07AB_ae) || (auto24AE07AB_ai < 0 && lv_itSkin >= auto24AE07AB_ae) ) ; lv_itSkin += auto24AE07AB_ai ) {

        libGame_gv_players[lv_itPlayerIndex].lv_heroData.lv_skinArray[lv_itSkin] = null;

    }

    libGame_gv_players[lv_itPlayerIndex].lv_heroData.lv_skinCount = 0;

    libGame_gv_players[lv_itPlayerIndex].lv_heroData.lv_skinArray[libGame_gv_players[lv_itPlayerIndex].lv_heroData.lv_skinCount] = "Default";

    libGame_gv_players[lp_index].lv_aIHeroDelegateTokenValue = libAIAI_gv_aITeamDelegateHeroTokenValueDefault_C;

}



void libCore_gf_DataLoadHeroDataIntoIndex (string lp_heroLink, int lp_index) {

    // Variable Declarations

    string lv_heroID;

    string lv_unitType;

    int lv_roleInt;

    int lv_expandedRoleInt;

    int lv_universeInt;

    int lv_genderInt;

    int lv_introCutsceneSizeInt;

    int lv_numberOfLevelUpAbils;

    int lv_numberOfLevelUpAbilMods;

    int lv_catalogInt;

    int lv_itAbility;

    int lv_itLevelUpAbility;

    int lv_itLevelUpAbilityMod;

    int lv_playerIndex;

    int lv_itSkin;

    int lv_itMountCategory;

    int lv_itAlternateHero;



    // Automatic Variable Declarations

    int auto825074B2_ae;

    const int auto825074B2_ai = 1;

    int auto05955D95_ae;

    const int auto05955D95_ai = 1;

    int autoC6FCBF13_ae;

    const int autoC6FCBF13_ai = 1;

    int auto449D5A13_ae;

    const int auto449D5A13_ai = 1;

    int auto1F3F17C2_ae;

    const int auto1F3F17C2_ai = 1;

    int autoD60722DD_ae;

    const int autoD60722DD_ai = 1;

    int auto982C7F79_ae;

    const int auto982C7F79_ai = 1;



    // Variable Initialization

    lv_heroID = "";



    // Implementation

    if (((lp_index <= 0) || (lp_heroLink == null))) {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Core_6A17A4D0"), true);

        return ;

    }



    lv_playerIndex = lp_index;

    lv_heroID = (lp_heroLink);

    lv_unitType = (CatalogFieldValueGet(c_gameCatalogHero, lp_heroLink, "Unit", c_playerAny));

    if ((CatalogEntryIsValid(c_gameCatalogUnit, lv_unitType) == false)) {

        TextExpressionSetToken("Param/Expression/lib_Core_07A76EFB", "A", StringToText(lv_heroID));

        TextExpressionSetToken("Param/Expression/lib_Core_07A76EFB", "B", StringToText((lv_unitType)));

        TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Core_07A76EFB"), true);

        return ;

    }



    if ((lv_unitType != null)) {

        libGame_gv_players[lv_playerIndex].lv_heroData.lv_heroCatalogLink = (lv_heroID);

        libGame_gv_players[lv_playerIndex].lv_heroData.lv_unitType = lv_unitType;

        libGame_gv_players[lv_playerIndex].lv_heroData.lv_name = UnitTypeGetName(lv_unitType);

        lv_roleInt = CatalogFieldValueGetAsInt(c_gameCatalogHero, lv_heroID, "Role", c_playerAny);

        lv_expandedRoleInt = CatalogFieldValueGetAsInt(c_gameCatalogHero, lv_heroID, "ExpandedRole", c_playerAny);

        lv_universeInt = CatalogFieldValueGetAsInt(c_gameCatalogHero, lv_heroID, "Universe", c_playerAny);

        lv_genderInt = CatalogFieldValueGetAsInt(c_gameCatalogHero, lv_heroID, "Gender", c_playerAny);

        libGame_gv_players[lv_playerIndex].lv_heroData.lv_role = lv_roleInt;

        libGame_gv_players[lv_playerIndex].lv_heroData.lv_expandedRole = lv_expandedRoleInt;

        libGame_gv_players[lv_playerIndex].lv_heroData.lv_universe = lv_universeInt;

        libGame_gv_players[lv_playerIndex].lv_heroData.lv_gender = lv_genderInt;

        libGame_gv_players[lv_playerIndex].lv_heroData.lv_isMelee = (CatalogFieldValueGetAsInt(c_gameCatalogHero, lv_heroID, "Melee", c_playerAny) != 0);

        libGame_gv_players[lv_playerIndex].lv_heroData.lv_description = StringExternal(CatalogFieldValueGet(c_gameCatalogHero, lv_heroID, "Description", c_playerAny));

        libGame_gv_players[lv_playerIndex].lv_heroData.lv_portrait = (CatalogFieldValueGet(c_gameCatalogHero, lv_heroID, "Portrait", c_playerAny));

        libGame_gv_players[lv_playerIndex].lv_heroData.lv_leaderboardImage = (CatalogFieldValueGet(c_gameCatalogHero, lv_heroID, "LeaderboardImage", c_playerAny));

        libGame_gv_players[lv_playerIndex].lv_heroData.lv_loadingScreenImage = (CatalogFieldValueGet(c_gameCatalogHero, lv_heroID, "LoadingScreenImage", c_playerAny));

        libGame_gv_players[lv_playerIndex].lv_heroData.lv_partyFrameImage = (CatalogFieldValueGet(c_gameCatalogHero, lv_heroID, "PartyFrameImage", c_playerAny));

        libGame_gv_players[lv_playerIndex].lv_heroData.lv_heroSelectScreenButtonPortrait = (CatalogFieldValueGet(c_gameCatalogHero, lv_heroID, "SelectScreenButtonImage", c_playerAny));

        lv_introCutsceneSizeInt = CatalogFieldValueGetAsInt(c_gameCatalogHero, lv_heroID, "IntroCutsceneSize", c_playerAny);

        libGame_gv_players[lv_playerIndex].lv_heroData.lv_introCutsceneSize = lv_introCutsceneSizeInt;

        libGame_gv_players[lv_playerIndex].lv_heroData.lv_isFlyer = (CatalogFieldValueGetAsInt(c_gameCatalogHero, lv_heroID, "Flags[Flyer]", c_playerAny) == 1);

        libGame_gv_players[lv_playerIndex].lv_heroData.lv_allowAIRandomSelection = (CatalogFieldValueGetAsInt(c_gameCatalogHero, lv_heroID, "Flags[AllowAIRandomSelection]", c_playerAny) == 1);

        libGame_gv_players[lv_playerIndex].lv_heroData.lv_allowHumanRandomSelection = (CatalogFieldValueGetAsInt(c_gameCatalogHero, lv_heroID, "Flags[AllowHumanRandomSelection]", c_playerAny) == 1);

        libGame_gv_players[lv_playerIndex].lv_heroData.lv_isPaired = (CatalogFieldValueGetAsInt(c_gameCatalogHero, lv_heroID, "Flags[IsSharedControlHero]", c_playerAny) == 1);

        libGame_gv_players[lv_playerIndex].lv_heroData.lv_dEBUGPlayable = true;

        if ((CatalogFieldValueCount(c_gameCatalogHero, lv_heroID, "AlternateUnitArray", c_playerAny) > libCore_gv_dataHeroesMaxAlternateHeroes)) {

            TextExpressionSetToken("Param/Expression/lib_Core_E416AC80", "A", StringToText(lv_heroID));

            TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Core_E416AC80"), true);

            libGame_gv_players[lv_playerIndex].lv_heroData.lv_numberOfAlternateUnitTypes = libCore_gv_dataHeroesMaxAlternateHeroes;

        }

        else {

            libGame_gv_players[lv_playerIndex].lv_heroData.lv_numberOfAlternateUnitTypes = CatalogFieldValueCount(c_gameCatalogHero, lv_heroID, "AlternateUnitArray", c_playerAny);

        }

        auto825074B2_ae = libGame_gv_players[lv_playerIndex].lv_heroData.lv_numberOfAlternateUnitTypes;

        lv_itAlternateHero = 1;

        for ( ; ( (auto825074B2_ai >= 0 && lv_itAlternateHero <= auto825074B2_ae) || (auto825074B2_ai < 0 && lv_itAlternateHero >= auto825074B2_ae) ) ; lv_itAlternateHero += auto825074B2_ai ) {

            libGame_gv_players[lv_playerIndex].lv_heroData.lv_alternateUnitTypes[lv_itAlternateHero] = (CatalogFieldValueGet(c_gameCatalogHero, lv_heroID, "AlternateUnitArray[" + IntToString((lv_itAlternateHero - 1)) + "]", c_playerAny));

        }

        if ((CatalogFieldValueCount(c_gameCatalogHero, lv_heroID, "HeroAbilArray", c_playerAny) > 0)) {

            libGame_gv_players[lv_playerIndex].lv_heroData.lv_numberOfAbilities = CatalogFieldValueCount(c_gameCatalogHero, lv_heroID, "HeroAbilArray", c_playerAny);

            if ((libGame_gv_players[lv_playerIndex].lv_heroData.lv_numberOfAbilities > libCore_gv_dataHeroesMaxAbilitiesPerHero)) {

                TextExpressionSetToken("Param/Expression/lib_Core_DCB480C5", "A", StringToText(lv_heroID));

                TextExpressionSetToken("Param/Expression/lib_Core_DCB480C5", "B", IntToText(libCore_gv_dataHeroesMaxAbilitiesPerHero));

                TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Core_DCB480C5"), true);

                libGame_gv_players[lv_playerIndex].lv_heroData.lv_numberOfAbilities = libCore_gv_dataHeroesMaxAbilitiesPerHero;

            }



            auto05955D95_ae = libGame_gv_players[lv_playerIndex].lv_heroData.lv_numberOfAbilities;

            lv_itAbility = 1;

            for ( ; ( (auto05955D95_ai >= 0 && lv_itAbility <= auto05955D95_ae) || (auto05955D95_ai < 0 && lv_itAbility >= auto05955D95_ae) ) ; lv_itAbility += auto05955D95_ai ) {

                libGame_gv_players[lv_playerIndex].lv_heroData.lv_abilities[lv_itAbility].lv_ability = (CatalogFieldValueGet(c_gameCatalogHero, lv_heroID, "HeroAbilArray[" + IntToString((lv_itAbility - 1)) + "].Abil", c_playerAny));

                libGame_gv_players[lv_playerIndex].lv_heroData.lv_abilities[lv_itAbility].lv_isAffectedByCooldownReduction = (CatalogFieldValueGetAsInt(c_gameCatalogHero, lv_heroID, "HeroAbilArray[" + IntToString((lv_itAbility - 1)) + "].Flags[" + IntToString(c_heroAbilFlagAffectedByCooldownReduction) + "]", c_playerAny) == 1);

                libGame_gv_players[lv_playerIndex].lv_heroData.lv_abilities[lv_itAbility].lv_isHeroic = (CatalogFieldValueGetAsInt(c_gameCatalogHero, lv_heroID, "HeroAbilArray[" + IntToString((lv_itAbility - 1)) + "].Flags[" + IntToString(c_heroAbilFlagHeroic) + "]", c_playerAny) == 1);

                libGame_gv_players[lv_playerIndex].lv_heroData.lv_abilities[lv_itAbility].lv_isTrait = (CatalogFieldValueGetAsInt(c_gameCatalogHero, lv_heroID, "HeroAbilArray[" + IntToString((lv_itAbility - 1)) + "].Flags[" + IntToString(c_heroAbilFlagTrait) + "]", c_playerAny) == 1);

                libGame_gv_players[lv_playerIndex].lv_heroData.lv_abilities[lv_itAbility].lv_usesCharges = (CatalogFieldValueGetAsInt(c_gameCatalogHero, lv_heroID, "HeroAbilArray[" + IntToString((lv_itAbility - 1)) + "].Flags[" + IntToString(c_heroAbilFlagUsesCharges) + "]", c_playerAny) == 1);

                libGame_gv_players[lv_playerIndex].lv_heroData.lv_abilities[lv_itAbility].lv_isAffectedByOverdrive = (CatalogFieldValueGetAsInt(c_gameCatalogHero, lv_heroID, "HeroAbilArray[" + IntToString((lv_itAbility - 1)) + "].Flags[" + IntToString(c_heroAbilFlagAffectedByOverdrive) + "]", c_playerAny) == 1);

                libGame_gv_players[lv_playerIndex].lv_heroData.lv_abilities[lv_itAbility].lv_isMountReplacement = (CatalogFieldValueGetAsInt(c_gameCatalogHero, lv_heroID, "HeroAbilArray[" + IntToString((lv_itAbility - 1)) + "].Flags[" + IntToString(c_heroAbilFlagMountReplacement) + "]", c_playerAny) == 1);

            }

        }

        else {

            TextExpressionSetToken("Param/Expression/lib_Core_136170F1", "A", StringToText(lv_heroID));

            TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Core_136170F1"), true);

        }

        lv_numberOfLevelUpAbils = CatalogFieldValueCount(c_gameCatalogHero, lv_heroID, "LevelScalingArray", c_playerAny);

        if ((lv_numberOfLevelUpAbils > libCore_gv_dataHeroesMaxAbilitiesPerHero)) {

            TextExpressionSetToken("Param/Expression/lib_Core_4A30C9DA", "A", StringToText(lv_heroID));

            TextExpressionSetToken("Param/Expression/lib_Core_4A30C9DA", "D", IntToText(libCore_gv_dataHeroesMaxAbilitiesPerHero));

            TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Core_4A30C9DA"), true);

            lv_numberOfLevelUpAbils = libCore_gv_dataHeroesMaxAbilitiesPerHero;

        }



        libGame_gv_players[lv_playerIndex].lv_heroData.lv_levelUpAbilitiesCount = lv_numberOfLevelUpAbils;

        autoC6FCBF13_ae = lv_numberOfLevelUpAbils;

        lv_itLevelUpAbility = 1;

        for ( ; ( (autoC6FCBF13_ai >= 0 && lv_itLevelUpAbility <= autoC6FCBF13_ae) || (autoC6FCBF13_ai < 0 && lv_itLevelUpAbility >= autoC6FCBF13_ae) ) ; lv_itLevelUpAbility += autoC6FCBF13_ai ) {

            lv_numberOfLevelUpAbilMods = CatalogFieldValueCount(c_gameCatalogHero, lv_heroID, "LevelScalingArray[" + IntToString(lv_itLevelUpAbility - 1) + "].Modifications", c_playerAny);

            if ((lv_numberOfLevelUpAbilMods > libCore_gv_dataMaxCatalogChangesPerAbility)) {

                TextExpressionSetToken("Param/Expression/lib_Core_C9F1F65D", "A", StringToText(lv_heroID));

                TextExpressionSetToken("Param/Expression/lib_Core_C9F1F65D", "D", IntToText(lv_numberOfLevelUpAbilMods));

                TextExpressionSetToken("Param/Expression/lib_Core_C9F1F65D", "E", StringToText(CatalogFieldValueGet(c_gameCatalogHero, lv_heroID, "LevelScalingArray[" + IntToString((lv_itLevelUpAbility - 1)) + "].Ability", c_playerAny)));

                TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Core_C9F1F65D"), true);

                lv_numberOfLevelUpAbilMods = libCore_gv_dataMaxCatalogChangesPerAbility;

            }



            libGame_gv_players[lv_playerIndex].lv_heroData.lv_levelUpModificationData.lv_numberOfFieldChanges[lv_itLevelUpAbility] = lv_numberOfLevelUpAbilMods;

            auto449D5A13_ae = lv_numberOfLevelUpAbilMods;

            lv_itLevelUpAbilityMod = 1;

            for ( ; ( (auto449D5A13_ai >= 0 && lv_itLevelUpAbilityMod <= auto449D5A13_ae) || (auto449D5A13_ai < 0 && lv_itLevelUpAbilityMod >= auto449D5A13_ae) ) ; lv_itLevelUpAbilityMod += auto449D5A13_ai ) {

                libGame_gv_players[lv_playerIndex].lv_heroData.lv_levelUpModificationData.lv_affectedByAbilityPower[lv_itLevelUpAbility][lv_itLevelUpAbilityMod] = (CatalogFieldValueGetAsInt(c_gameCatalogHero, lv_heroID, "LevelScalingArray[" + IntToString((lv_itLevelUpAbility - 1)) + "].Modifications[" + IntToString((lv_itLevelUpAbilityMod - 1)) + "].AffectedByAbilityPower", c_playerAny) == 1);

                libGame_gv_players[lv_playerIndex].lv_heroData.lv_levelUpModificationData.lv_percentScaled[lv_itLevelUpAbility][lv_itLevelUpAbilityMod] = (CatalogFieldValueGetAsInt(c_gameCatalogHero, lv_heroID, "LevelScalingArray[" + IntToString((lv_itLevelUpAbility - 1)) + "].Modifications[" + IntToString((lv_itLevelUpAbilityMod - 1)) + "].AffectedByOverdrive", c_playerAny) == 1);

                lv_catalogInt = CatalogFieldValueGetAsInt(c_gameCatalogHero, lv_heroID, "LevelScalingArray[" + IntToString((lv_itLevelUpAbility - 1)) + "].Modifications[" + IntToString((lv_itLevelUpAbilityMod - 1)) + "].Catalog", c_playerAny);

                libGame_gv_players[lv_playerIndex].lv_heroData.lv_levelUpModificationData.lv_catalog[lv_itLevelUpAbility][lv_itLevelUpAbilityMod] = lv_catalogInt;

                libGame_gv_players[lv_playerIndex].lv_heroData.lv_levelUpModificationData.lv_entry[lv_itLevelUpAbility][lv_itLevelUpAbilityMod] = CatalogFieldValueGet(c_gameCatalogHero, lv_heroID, "LevelScalingArray[" + IntToString((lv_itLevelUpAbility - 1)) + "].Modifications[" + IntToString((lv_itLevelUpAbilityMod - 1)) + "].Entry", c_playerAny);

                libGame_gv_players[lv_playerIndex].lv_heroData.lv_levelUpModificationData.lv_field[lv_itLevelUpAbility][lv_itLevelUpAbilityMod] = CatalogFieldValueGet(c_gameCatalogHero, lv_heroID, "LevelScalingArray[" + IntToString((lv_itLevelUpAbility - 1)) + "].Modifications[" + IntToString((lv_itLevelUpAbilityMod - 1)) + "].Field", c_playerAny);

                libGame_gv_players[lv_playerIndex].lv_heroData.lv_levelUpModificationData.lv_fieldIsInteger[lv_itLevelUpAbility][lv_itLevelUpAbilityMod] = (CatalogFieldValueGetAsInt(c_gameCatalogHero, lv_heroID, "LevelScalingArray[" + IntToString((lv_itLevelUpAbility - 1)) + "].Modifications[" + IntToString((lv_itLevelUpAbilityMod - 1)) + "].FieldIsInteger", c_playerAny) == 1);

                libGame_gv_players[lv_playerIndex].lv_heroData.lv_levelUpModificationData.lv_valueAddedPerLevel[lv_itLevelUpAbility][lv_itLevelUpAbilityMod] = CatalogFieldValueGetAsFixed(c_gameCatalogHero, lv_heroID, "LevelScalingArray[" + IntToString((lv_itLevelUpAbility - 1)) + "].Modifications[" + IntToString((lv_itLevelUpAbilityMod - 1)) + "].Value", c_playerAny);

            }

        }

        libGame_gv_players[lv_playerIndex].lv_heroData.lv_usesMounts = (CatalogFieldValueGetAsInt(c_gameCatalogHero, lv_heroID, "Flags[UsesMount]", c_playerAny) != 0);

        libGame_gv_players[lv_playerIndex].lv_heroData.lv_allowedMountCategoryCount = CatalogFieldValueCount(c_gameCatalogHero, lv_heroID, "AllowedMountCategoryArray", c_playerAny);

        if ((libGame_gv_players[lv_playerIndex].lv_heroData.lv_allowedMountCategoryCount > libCore_gv_data_MaxHeroAllowedMountCategories_C)) {

            TextExpressionSetToken("Param/Expression/lib_Core_CB418692", "A", StringToText(lv_heroID));

            TextExpressionSetToken("Param/Expression/lib_Core_CB418692", "B", IntToText(libCore_gv_data_MaxHeroAllowedMountCategories_C));

            TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Core_CB418692"), true);

            libGame_gv_players[lv_playerIndex].lv_heroData.lv_allowedMountCategoryCount = libCore_gv_data_MaxHeroAllowedMountCategories_C;

        }



        auto1F3F17C2_ae = libGame_gv_players[lv_playerIndex].lv_heroData.lv_allowedMountCategoryCount;

        lv_itMountCategory = 1;

        for ( ; ( (auto1F3F17C2_ai >= 0 && lv_itMountCategory <= auto1F3F17C2_ae) || (auto1F3F17C2_ai < 0 && lv_itMountCategory >= auto1F3F17C2_ae) ) ; lv_itMountCategory += auto1F3F17C2_ai ) {

            libGame_gv_players[lv_playerIndex].lv_heroData.lv_allowedMountCategories[lv_itMountCategory] = CatalogFieldValueGet(c_gameCatalogHero, lv_heroID, "AllowedMountCategoryArray[" + IntToString((lv_itMountCategory - 1)) + "]", c_playerAny);

        }

        libGame_gv_players[lv_playerIndex].lv_heroData.lv_defaultMount = (CatalogFieldValueGet(c_gameCatalogHero, lv_heroID, "DefaultMount", c_playerAny));

        libGame_gv_players[lv_playerIndex].lv_heroData.lv_skinCount += 1;

        libGame_gv_players[lv_playerIndex].lv_heroData.lv_skinArray[libGame_gv_players[lv_playerIndex].lv_heroData.lv_skinCount] = "Default";

        autoD60722DD_ae = (CatalogFieldValueCount(c_gameCatalogHero, lv_heroID, "SkinArray", c_playerAny) - 1);

        lv_itSkin = 0;

        for ( ; ( (autoD60722DD_ai >= 0 && lv_itSkin <= autoD60722DD_ae) || (autoD60722DD_ai < 0 && lv_itSkin >= autoD60722DD_ae) ) ; lv_itSkin += autoD60722DD_ai ) {

            libCore_gf_DataHeroesAddSkinPlusVariationsToHero(lv_playerIndex, (CatalogFieldValueGet(c_gameCatalogHero, lv_heroID, "SkinArray[" + IntToString(lv_itSkin) + "]", c_playerAny)));

        }

        auto982C7F79_ae = (CatalogFieldValueCount(c_gameCatalogHero, lv_heroID, "VariationArray", c_playerAny) - 1);

        lv_itSkin = 0;

        for ( ; ( (auto982C7F79_ai >= 0 && lv_itSkin <= auto982C7F79_ae) || (auto982C7F79_ai < 0 && lv_itSkin >= auto982C7F79_ae) ) ; lv_itSkin += auto982C7F79_ai ) {

            libCore_gf_DataHeroesAddSkinPlusVariationsToHero(lv_playerIndex, (CatalogFieldValueGet(c_gameCatalogHero, lv_heroID, "VariationArray[" + IntToString(lv_itSkin) + "]", c_playerAny)));

        }

    }



    if ((lp_heroLink == "Rexxar")) {

        libGame_gv_players[lp_index].lv_aIHeroDelegateTokenValue = libGDHL_gv_aIHeroDelegateTokenValueRexxarValue;

    }



    if ((lp_heroLink == "LostVikings")) {

        libGame_gv_players[lp_index].lv_aIHeroDelegateTokenValue = libGDHL_gv_aIHeroDelegateTokenValueAnyVikingAliveValue;

    }



}



void libCore_gf_DataHeroVOMapDataField (int lp_event, string lp_arrayIndexName) {

    // Automatic Variable Declarations

    // Implementation

    if ((lp_arrayIndexName == "")) {

        libCore_gv_dataHeroVODataFieldMap[(lp_event)] = "";

    }

    else {

        libCore_gv_dataHeroVODataFieldMap[(lp_event)] = ("VOArray[" + lp_arrayIndexName + "]");

    }

}



void libCore_gf_DataHeroVOReloadHeroVODataForHero (int lp_player) {

    // Variable Declarations

    string lv_excludedSkinString;

    int lv_requiredSkinCount;

    int lv_eventindex;

    int lv_lineindex;

    int lv_itPlayer;

    int lv_playerHeroIndex;

    string lv_heroCatalogLink;

    string lv_dataField;

    int lv_itSkin;

    int lv_itPlayerSkin;

    int lv_excludedSkinCountforKills;

    int lv_requiredSkinCountforKills;

    int lv_itExcludedSkin;



    // Automatic Variable Declarations

    const int auto6C6F056D_ae = libCore_gv_dataHeroVOMaxNumberOfHeroVOEvents;

    const int auto6C6F056D_ai = 1;



    // Variable Initialization

    lv_excludedSkinString = "";

    lv_dataField = "";



    // Implementation

    lv_heroCatalogLink = libGame_gv_players[lp_player].lv_heroData.lv_heroCatalogLink;

    if ((lv_heroCatalogLink != null)) {

        lv_eventindex = 1;

        for ( ; ( (auto6C6F056D_ai >= 0 && lv_eventindex <= auto6C6F056D_ae) || (auto6C6F056D_ai < 0 && lv_eventindex >= auto6C6F056D_ae) ) ; lv_eventindex += auto6C6F056D_ai ) {

            lv_dataField = libCore_gv_dataHeroVODataFieldMap[lv_eventindex];

            if ((lv_dataField != "")) {

                libCore_gv_dataHeroVO[lp_player].lv_vOEventLines[lv_eventindex] = (CatalogFieldValueGet(c_gameCatalogHero, lv_heroCatalogLink, lv_dataField, lp_player));

            }



        }

    }



}



string libCore_gf_GetSprayFromIndex (int lp_index) {

    // Variable Declarations

    string lv_value;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_value = "";



    // Implementation

    lv_value = DataTableGetString(true, ("SprayIndex_" + IntToString(lp_index)));

    return (lv_value);

}



void libCore_gf_DataLootContentLoadSprayDataIntoIndex (string lp_sprayLink, int lp_playerIndex) {

    // Variable Declarations

    int lv_itRequiredReward;

    int lv_itActorMessage;

    string lv_sprayModelID;



    // Automatic Variable Declarations

    int auto299418C4_ae;

    const int auto299418C4_ai = 1;



    // Variable Initialization

    lv_sprayModelID = "";



    // Implementation

    if (((lp_sprayLink == "") || (CatalogEntryIsValid(c_gameCatalogSpray, lp_sprayLink) == false))) {

        libCore_gf_DataLootContentLoadSprayDataIntoIndex(libCore_gv_mountModelActor4, lp_playerIndex);

        return ;

    }



    lv_sprayModelID = CatalogFieldValueGet(c_gameCatalogSpray, lp_sprayLink, "Model", c_playerAny);

    libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_Spray.lv_sprayID = lp_sprayLink;

    libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_Spray.lv_sprayModelID = (lv_sprayModelID);

    libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_Spray.lv_requiredRewardCount = CatalogFieldValueCount(c_gameCatalogSpray, lp_sprayLink, "RequiredRewardArray", c_playerAny);

    auto299418C4_ae = libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_Spray.lv_requiredRewardCount;

    lv_itRequiredReward = 1;

    for ( ; ( (auto299418C4_ai >= 0 && lv_itRequiredReward <= auto299418C4_ae) || (auto299418C4_ai < 0 && lv_itRequiredReward >= auto299418C4_ae) ) ; lv_itRequiredReward += auto299418C4_ai ) {

        libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_Spray.lv_requiredRewardArray[lv_itRequiredReward] = (CatalogFieldValueGet(c_gameCatalogSpray, lp_sprayLink, "RequiredRewardArray[" + IntToString((lv_itRequiredReward - 1)) + "]", c_playerAny));

    }

}



void libCore_gf_DataLootContentClearSprayDataAtIndex (int lp_playerIndex) {

    // Variable Declarations

    int lv_itRequiredReward;

    int lv_itActorMessage;



    // Automatic Variable Declarations

    int auto9E824BB9_ae;

    const int auto9E824BB9_ai = 1;



    // Variable Initialization



    // Implementation

    libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_Spray.lv_sprayID = null;

    libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_Spray.lv_sprayModelID = null;

    auto9E824BB9_ae = libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_Spray.lv_requiredRewardCount;

    lv_itRequiredReward = 1;

    for ( ; ( (auto9E824BB9_ai >= 0 && lv_itRequiredReward <= auto9E824BB9_ae) || (auto9E824BB9_ai < 0 && lv_itRequiredReward >= auto9E824BB9_ae) ) ; lv_itRequiredReward += auto9E824BB9_ai ) {

        libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_Spray.lv_requiredRewardArray[lv_itRequiredReward] = null;

    }

    libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_Spray.lv_requiredRewardCount = 0;

}



string libCore_gf_GetBannerFromIndex (int lp_index) {

    // Variable Declarations

    string lv_value;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_value = "";



    // Implementation

    lv_value = DataTableGetString(true, ("BannerIndex_" + IntToString(lp_index)));

    return (lv_value);

}



void libCore_gf_DataLootContentLoadBannerDataIntoIndex (string lp_bannerLink, int lp_playerIndex) {

    // Variable Declarations

    int lv_itRequiredReward;

    int lv_itActorMessage;

    string lv_bannerModelID;



    // Automatic Variable Declarations

    int auto0C5398EB_ae;

    const int auto0C5398EB_ai = 1;

    int autoC7408AC5_ae;

    const int autoC7408AC5_ai = 1;



    // Variable Initialization

    lv_bannerModelID = "";



    // Implementation

    lv_bannerModelID = CatalogFieldValueGet(c_gameCatalogBanner, lp_bannerLink, "Model", c_playerAny);

    if ((lv_bannerModelID == "")) {

        TextExpressionSetToken("Param/Expression/lib_Core_084151F0", "A", StringToText((lp_bannerLink)));

        TextExpressionSetToken("Param/Expression/lib_Core_084151F0", "B", IntToText(lp_playerIndex));

        TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Core_084151F0"), true);

        return ;

    }



    libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_Banner.lv_bannerID = lp_bannerLink;

    libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_Banner.lv_bannerModelID = (lv_bannerModelID);

    libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_Banner.lv_requiredRewardCount = CatalogFieldValueCount(c_gameCatalogBanner, lp_bannerLink, "RequiredRewardArray", c_playerAny);

    auto0C5398EB_ae = libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_Spray.lv_requiredRewardCount;

    lv_itRequiredReward = 1;

    for ( ; ( (auto0C5398EB_ai >= 0 && lv_itRequiredReward <= auto0C5398EB_ae) || (auto0C5398EB_ai < 0 && lv_itRequiredReward >= auto0C5398EB_ae) ) ; lv_itRequiredReward += auto0C5398EB_ai ) {

        libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_Banner.lv_requiredRewardArray[lv_itRequiredReward] = (CatalogFieldValueGet(c_gameCatalogBanner, lp_bannerLink, "RequiredRewardArray[" + IntToString((lv_itRequiredReward - 1)) + "]", c_playerAny));

    }

    libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_Banner.lv_actorMessageCount = CatalogFieldValueCount(c_gameCatalogBanner, lp_bannerLink, "CreationActorMessageArray", c_playerAny);

    autoC7408AC5_ae = libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_Banner.lv_actorMessageCount;

    lv_itActorMessage = 1;

    for ( ; ( (autoC7408AC5_ai >= 0 && lv_itActorMessage <= autoC7408AC5_ae) || (autoC7408AC5_ai < 0 && lv_itActorMessage >= autoC7408AC5_ae) ) ; lv_itActorMessage += autoC7408AC5_ai ) {

        libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_Banner.lv_actorMessageArray[lv_itActorMessage] = CatalogFieldValueGet(c_gameCatalogBanner, lp_bannerLink, "CreationActorMessageArray[" + IntToString((lv_itActorMessage - 1)) + "].Send", c_playerAny);

    }

}



void libCore_gf_DataLootContentClearBannerDataAtIndex (int lp_playerIndex) {

    // Variable Declarations

    int lv_itRequiredReward;

    int lv_itActorMessage;



    // Automatic Variable Declarations

    int auto8D69A828_ae;

    const int auto8D69A828_ai = 1;

    int auto0F35B6B4_ae;

    const int auto0F35B6B4_ai = 1;



    // Variable Initialization



    // Implementation

    libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_Banner.lv_bannerID = null;

    libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_Banner.lv_bannerModelID = null;

    auto8D69A828_ae = libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_Spray.lv_requiredRewardCount;

    lv_itRequiredReward = 1;

    for ( ; ( (auto8D69A828_ai >= 0 && lv_itRequiredReward <= auto8D69A828_ae) || (auto8D69A828_ai < 0 && lv_itRequiredReward >= auto8D69A828_ae) ) ; lv_itRequiredReward += auto8D69A828_ai ) {

        libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_Banner.lv_requiredRewardArray[lv_itRequiredReward] = null;

    }

    libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_Banner.lv_requiredRewardCount = 0;

    auto0F35B6B4_ae = libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_Banner.lv_actorMessageCount;

    lv_itActorMessage = 1;

    for ( ; ( (auto0F35B6B4_ai >= 0 && lv_itActorMessage <= auto0F35B6B4_ae) || (auto0F35B6B4_ai < 0 && lv_itActorMessage >= auto0F35B6B4_ae) ) ; lv_itActorMessage += auto0F35B6B4_ai ) {

        libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_Banner.lv_actorMessageArray[lv_itActorMessage] = "";

    }

    libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_Banner.lv_actorMessageCount = 0;

}



string libCore_gf_GetAnnouncerPackFromIndex (int lp_index) {

    // Variable Declarations

    string lv_value;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_value = "";



    // Implementation

    lv_value = DataTableGetString(true, ("AnnouncerPackIndex_" + IntToString(lp_index)));

    return (lv_value);

}



void libCore_gf_DataLootContentLoadAnnouncerPackDataIntoIndex (string lp_announcerPackLink, int lp_playerIndex, bool lp_announcerIsPlayerAssigned) {

    // Variable Declarations

    int lv_itRequiredReward;

    int lv_itActorMessage;

    string lv_announcerVOID;

    int lv_itEvent;

    string lv_dataFieldMapString;

    string lv_soundID;



    // Automatic Variable Declarations

    int auto5357C182_ae;

    const int auto5357C182_ai = 1;

    const int auto3BA7A327_ae = libCore_gv_dataAnnouncerVOMaxNumberOfAnnouncerEvents;

    const int auto3BA7A327_ai = 1;



    // Variable Initialization

    lv_announcerVOID = "";

    lv_dataFieldMapString = "";



    // Implementation

    if ((lp_announcerPackLink != "") && (CatalogEntryIsValid(c_gameCatalogAnnouncerPack, lp_announcerPackLink) == true)) {

        lv_announcerVOID = CatalogFieldValueGet(c_gameCatalogAnnouncerPack, lp_announcerPackLink, "VoiceOver", c_playerAny);

    }



    if ((lv_announcerVOID == "")) {

        return ;

    }



    libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_AnnouncerPack.lv_announcerPackID = lp_announcerPackLink;

    libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_AnnouncerPack.lv_announcerVoiceOverID = (lv_announcerVOID);

    libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_AnnouncerPack.lv_announcerHeroID = (CatalogFieldValueGet(c_gameCatalogAnnouncerPack, lp_announcerPackLink, "Hero", c_playerAny));

    libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_AnnouncerPack.lv_announcerIsPlayerAssigned = lp_announcerIsPlayerAssigned;

    libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_AnnouncerPack.lv_requiredRewardCount = CatalogFieldValueCount(c_gameCatalogAnnouncerPack, lp_announcerPackLink, "RequiredRewardArray", c_playerAny);

    auto5357C182_ae = libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_AnnouncerPack.lv_requiredRewardCount;

    lv_itRequiredReward = 1;

    for ( ; ( (auto5357C182_ai >= 0 && lv_itRequiredReward <= auto5357C182_ae) || (auto5357C182_ai < 0 && lv_itRequiredReward >= auto5357C182_ae) ) ; lv_itRequiredReward += auto5357C182_ai ) {

        libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_AnnouncerPack.lv_requiredRewardArray[lv_itRequiredReward] = (CatalogFieldValueGet(c_gameCatalogAnnouncerPack, lp_announcerPackLink, "RequiredRewardArray[" + IntToString((lv_itRequiredReward - 1)) + "]", c_playerAny));

    }

    lv_itEvent = 1;

    for ( ; ( (auto3BA7A327_ai >= 0 && lv_itEvent <= auto3BA7A327_ae) || (auto3BA7A327_ai < 0 && lv_itEvent >= auto3BA7A327_ae) ) ; lv_itEvent += auto3BA7A327_ai ) {

        if ((lv_itEvent == libCore_ge_AnnouncerVOEvents_GetReadyForBattle) && (libGame_gv_players[lp_playerIndex].lv_heroData.lv_heroCatalogLink == libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_AnnouncerPack.lv_announcerHeroID)) {

            lv_dataFieldMapString = (libCore_gv_dataAnnouncerVODataFieldMap[lv_itEvent].lv_vOString + "Player");

        }

        else {

            lv_dataFieldMapString = libCore_gv_dataAnnouncerVODataFieldMap[lv_itEvent].lv_vOString;

        }

        if ((lv_dataFieldMapString == "")) {

            TextExpressionSetToken("Param/Expression/lib_Core_4FA37383", "A", IntToText(lv_itEvent));

            TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Core_4FA37383"), false);

            continue;

        }



        lv_soundID = ((lv_announcerVOID + "_" + lv_dataFieldMapString));

        if ((CatalogEntryIsValid(c_gameCatalogSound, lv_soundID) == true)) {

            libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_AnnouncerPack.lv_announcerVOLines[lv_itEvent].lv_soundLink = lv_soundID;

            libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_AnnouncerPack.lv_announcerVOLines[lv_itEvent].lv_playAtGameEnd = libCore_gv_dataAnnouncerVODataFieldMap[lv_itEvent].lv_playAtGameEnd;

        }

        else {

            TextExpressionSetToken("Param/Expression/lib_Core_E44142A8", "A", StringToText((lv_soundID)));

            TextExpressionSetToken("Param/Expression/lib_Core_E44142A8", "B", StringToText(lv_announcerVOID));

            TextExpressionSetToken("Param/Expression/lib_Core_E44142A8", "C", IntToText(lp_playerIndex));

            TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Core_E44142A8"), false);

        }

    }

}



void libCore_gf_DataLootContentClearAnnouncerPackDataAtIndex (int lp_playerIndex) {

    // Variable Declarations

    int lv_itRequiredReward;



    // Automatic Variable Declarations

    int autoB872806B_ae;

    const int autoB872806B_ai = 1;



    // Variable Initialization



    // Implementation

    libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_AnnouncerPack.lv_announcerPackID = null;

    libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_AnnouncerPack.lv_announcerVoiceOverID = null;

    autoB872806B_ae = libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_AnnouncerPack.lv_requiredRewardCount;

    lv_itRequiredReward = 1;

    for ( ; ( (autoB872806B_ai >= 0 && lv_itRequiredReward <= autoB872806B_ae) || (autoB872806B_ai < 0 && lv_itRequiredReward >= autoB872806B_ae) ) ; lv_itRequiredReward += autoB872806B_ai ) {

        libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_AnnouncerPack.lv_requiredRewardArray[lv_itRequiredReward] = null;

    }

    libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_AnnouncerPack.lv_requiredRewardCount = 0;

    libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_AnnouncerPack.lv_announcerIsPlayerAssigned = false;

}



string libCore_gf_GetVoiceLineFromHeroIndex (int lp_voiceLineIndex, int lp_heroIndex) {

    // Variable Declarations

    string lv_value;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_value = "";



    // Implementation

    lv_value = DataTableGetString(true, ("HeroIndex_" + IntToString(lp_heroIndex) + "_VoiceLineIndex_" + IntToString(lp_voiceLineIndex)));

    return (lv_value);

}



string libCore_gf_GetDefaultVoiceLineForPlayer (int lp_player) {

    // Variable Declarations

    string lv_value;

    string lv_hero;

    string lv_skin;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_value = "";

    lv_hero = PlayerHero(lp_player);

    lv_skin = PlayerSkin(lp_player);



    // Implementation

    if ((lv_skin != "") && (CatalogEntryIsValid(c_gameCatalogSkin, lv_skin) == true) && (CatalogFieldValueCount(c_gameCatalogSkin, lv_skin, "VoiceLineArray", c_playerAny) > 1)) {

        lv_value = CatalogFieldValueGet(c_gameCatalogSkin, lv_skin, "VoiceLineArray[" + IntToString(0) + "]", c_playerAny);

        return (lv_value);

    }



    if ((lv_hero != "") && (CatalogEntryIsValid(c_gameCatalogHero, lv_hero) == true) && (CatalogFieldValueCount(c_gameCatalogHero, lv_hero, "VoiceLineArray", c_playerAny) > 1)) {

        lv_value = CatalogFieldValueGet(c_gameCatalogHero, lv_hero, "VoiceLineArray[" + IntToString(0) + "]", c_playerAny);

        return (lv_value);

    }



    return (lv_value);

}



int libCore_gf_VoiceLineCountFromHeroIndex (int lp_heroIndex) {

    // Variable Declarations

    int lv_value;



    // Automatic Variable Declarations

    // Variable Initialization



    // Implementation

    lv_value = DataTableGetInt(true, ("HeroIndex_" + IntToString(lp_heroIndex) + "_VoiceLineCount"));

    return lv_value;

}



void libCore_gf_DataLootContentLoadVoiceLineDataIntoIndex (string lp_voiceLine, int lp_playerIndex) {

    // Variable Declarations

    string lv_voiceLineDefault;

    int lv_itRequiredReward;

    int lv_itActorMessage;

    string lv_voiceLineSoundID;



    // Automatic Variable Declarations

    int autoE8F62969_ae;

    const int autoE8F62969_ai = 1;



    // Variable Initialization

    lv_voiceLineSoundID = "";



    // Implementation

    if (((lp_voiceLine == "") || (CatalogEntryIsValid(c_gameCatalogVoiceLine, lp_voiceLine) == false))) {

        lv_voiceLineDefault = libCore_gf_GetDefaultVoiceLineForPlayer(lp_playerIndex);

        if ((lv_voiceLineDefault != "") && (lv_voiceLineDefault != lp_voiceLine) && (CatalogEntryIsValid(c_gameCatalogVoiceLine, lv_voiceLineDefault) == true)) {

            libCore_gf_DataLootContentLoadVoiceLineDataIntoIndex(lv_voiceLineDefault, lp_playerIndex);

        }



        return ;

    }



    lv_voiceLineSoundID = CatalogFieldValueGet(c_gameCatalogVoiceLine, lp_voiceLine, "Sound", c_playerAny);

    libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_VoiceLine.lv_voiceLineID = lp_voiceLine;

    libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_VoiceLine.lv_voiceLineSoundID = (CatalogFieldValueGet(c_gameCatalogVoiceLine, lp_voiceLine, "Sound", c_playerAny));

    libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_VoiceLine.lv_requiredRewardCount = CatalogFieldValueCount(c_gameCatalogVoiceLine, lp_voiceLine, "RequiredRewardArray", c_playerAny);

    autoE8F62969_ae = libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_VoiceLine.lv_requiredRewardCount;

    lv_itRequiredReward = 1;

    for ( ; ( (autoE8F62969_ai >= 0 && lv_itRequiredReward <= autoE8F62969_ae) || (autoE8F62969_ai < 0 && lv_itRequiredReward >= autoE8F62969_ae) ) ; lv_itRequiredReward += autoE8F62969_ai ) {

        libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_VoiceLine.lv_requiredRewardArray[lv_itRequiredReward] = (CatalogFieldValueGet(c_gameCatalogVoiceLine, lp_voiceLine, "RequiredRewardArray[" + IntToString((lv_itRequiredReward - 1)) + "]", c_playerAny));

    }

}



void libCore_gf_DataLootContentClearVoiceLineDataAtIndex (int lp_playerIndex) {

    // Variable Declarations

    int lv_itRequiredReward;



    // Automatic Variable Declarations

    int autoC114B43B_ae;

    const int autoC114B43B_ai = 1;



    // Variable Initialization



    // Implementation

    libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_VoiceLine.lv_voiceLineID = null;

    libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_VoiceLine.lv_voiceLineSoundID = null;

    autoC114B43B_ae = libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_VoiceLine.lv_requiredRewardCount;

    lv_itRequiredReward = 1;

    for ( ; ( (autoC114B43B_ai >= 0 && lv_itRequiredReward <= autoC114B43B_ae) || (autoC114B43B_ai < 0 && lv_itRequiredReward >= autoC114B43B_ae) ) ; lv_itRequiredReward += autoC114B43B_ai ) {

        libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_VoiceLine.lv_requiredRewardArray[lv_itRequiredReward] = null;

    }

    libGame_gv_players[lp_playerIndex].lv_lootContent.lv_loot_VoiceLine.lv_requiredRewardCount = 0;

}



string libCore_gf_DataMinionUnitTypeFromPreset (int lp_type) {

    // Variable Declarations

    string lv_spawnUnitType;



    // Automatic Variable Declarations

    // Variable Initialization



    // Implementation

    return libCore_gv_dataMinionData[(lp_type)].lv_unitType;

}



bool libCore_gf_DataMinionTypeIsCatapult (int lp_minionType) {

    // Automatic Variable Declarations

    // Implementation

    if (((lp_minionType == libCore_ge_MinionTypes_Catapult) || (lp_minionType == libCore_ge_MinionTypes_CustomCatapult1) || (lp_minionType == libCore_ge_MinionTypes_CustomCatapult2) || (lp_minionType == libCore_ge_MinionTypes_CustomCatapult3))) {

        return true;

    }



    return false;

}



void libCore_gf_DataInitializeScalingDataForMinion (string lp_unitType, int lp_minionType) {

    // Variable Declarations

    int lv_itRank;

    int lv_minionTypeIndex;



    // Automatic Variable Declarations

    // Variable Initialization



    // Implementation

    libCore_gv_dataMinionData[(lp_minionType)].lv_unitType = lp_unitType;

    lv_minionTypeIndex = (lp_minionType);

}



string libCore_gf_DataSkinsGetMountLinkFromMountIndex (int lp_index) {

    // Automatic Variable Declarations

    // Implementation

    return (DataTableGetString(true, ("MountIndex_" + IntToString(lp_index))));

}



int libCore_gf_DataMountGetMountConfigIndexFromMountLink (string lp_mountLink) {

    // Variable Declarations

    string lv_mountCategory;

    int lv_itMountCategory;

    int lv_itMount;



    // Automatic Variable Declarations

    int autoC8475757_ae;

    const int autoC8475757_ai = 1;



    // Variable Initialization

    lv_mountCategory = "";



    // Implementation

    lv_mountCategory = CatalogFieldValueGet(c_gameCatalogMount, lp_mountLink, "MountCategory", c_playerAny);

    autoC8475757_ae = DataTableGetInt(true, ("Mounts_MountCategory_" + lv_mountCategory + "_MountCount"));

    lv_itMount = 1;

    for ( ; ( (autoC8475757_ai >= 0 && lv_itMount <= autoC8475757_ae) || (autoC8475757_ai < 0 && lv_itMount >= autoC8475757_ae) ) ; lv_itMount += autoC8475757_ai ) {

        if ((lp_mountLink == (DataTableGetString(true, ("Mounts_MountCategory_" + lv_mountCategory + "_Index_" + IntToString(lv_itMount) + "_ID"))))) {

            return DataTableGetInt(true, ("Mounts_MountCategory_" + lv_mountCategory + "_Index_" + IntToString(lv_itMount) + "_CatalogIndex"));

        }



    }

    return 0;

}



int libCore_gf_DataMountGetMountIndexFromMountLink (string lp_mountLink) {

    // Variable Declarations

    string lv_mountCategory;

    int lv_itMountCategory;

    int lv_itMount;



    // Automatic Variable Declarations

    int auto10922B9B_ae;

    const int auto10922B9B_ai = 1;



    // Variable Initialization

    lv_mountCategory = "";



    // Implementation

    if ((CatalogEntryIsValid(c_gameCatalogMount, lp_mountLink) == false)) {

        return 0;

    }



    lv_mountCategory = CatalogFieldValueGet(c_gameCatalogMount, lp_mountLink, "MountCategory", c_playerAny);

    auto10922B9B_ae = DataTableGetInt(true, ("Mounts_MountCategory_" + lv_mountCategory + "_MountCount"));

    lv_itMount = 1;

    for ( ; ( (auto10922B9B_ai >= 0 && lv_itMount <= auto10922B9B_ae) || (auto10922B9B_ai < 0 && lv_itMount >= auto10922B9B_ae) ) ; lv_itMount += auto10922B9B_ai ) {

        if ((lp_mountLink == (DataTableGetString(true, ("Mounts_MountCategory_" + lv_mountCategory + "_Index_" + IntToString(lv_itMount) + "_ID"))))) {

            return DataTableGetInt(true, ("Mounts_MountCategory_" + lv_mountCategory + "_Index_" + IntToString(lv_itMount) + "_Index"));

        }



    }

    return 0;

}



bool libCore_gf_DataMountMountIsValidForHeroSkin (int lp_heroIndex, int lp_skinIndex, int lp_mountIndex) {

    // Variable Declarations

    int lv_itCategory;

    int lv_itSkinCategory;

    string lv_mountCategory;



    // Automatic Variable Declarations

    int auto4B94B86E_ae;

    const int auto4B94B86E_ai = 1;

    int autoE654268E_ae;

    const int autoE654268E_ai = 1;



    // Variable Initialization

    lv_mountCategory = "";



    // Implementation

    lv_mountCategory = CatalogFieldValueGet(c_gameCatalogMount, libCore_gf_DataSkinsGetMountLinkFromMountIndex(lp_mountIndex), "MountCategory", c_playerAny);

    auto4B94B86E_ae = DataTableGetInt(true, ("HeroIndex_" + IntToString(lp_heroIndex) + "_MountCategoryCount"));

    lv_itCategory = 1;

    for ( ; ( (auto4B94B86E_ai >= 0 && lv_itCategory <= auto4B94B86E_ae) || (auto4B94B86E_ai < 0 && lv_itCategory >= auto4B94B86E_ae) ) ; lv_itCategory += auto4B94B86E_ai ) {

        if ((DataTableGetBool(true, ("HeroIndex_" + IntToString(lp_heroIndex) + "_MountCategoryIndex_" + IntToString(lv_itCategory) + "_GrantedBySkin")) == false)) {

            if ((lv_mountCategory == DataTableGetString(true, ("HeroIndex_" + IntToString(lp_heroIndex) + "_MountCategoryIndex_" + IntToString(lv_itCategory))))) {

                return true;

            }



        }

        else {

            autoE654268E_ae = DataTableGetInt(true, ("SkinIndex_" + IntToString(lp_skinIndex) + "_MountCategoryCount"));

            lv_itSkinCategory = 1;

            for ( ; ( (autoE654268E_ai >= 0 && lv_itSkinCategory <= autoE654268E_ae) || (autoE654268E_ai < 0 && lv_itSkinCategory >= autoE654268E_ae) ) ; lv_itSkinCategory += autoE654268E_ai ) {

                if ((lv_mountCategory == DataTableGetString(true, ("SkinIndex_" + IntToString(lp_skinIndex) + "_MountCategoryIndex_" + IntToString(lv_itSkinCategory))))) {

                    return true;

                }



            }

        }

    }

    return false;

}



fixed libCore_gf_DataMountGetMountModelScaleAtConfigIndex (int lp_catalogIndex) {

    // Automatic Variable Declarations

    // Implementation

    return CatalogFieldValueGetAsFixed(c_gameCatalogConfig, "Config", "MountArray[" + IntToString((lp_catalogIndex - 1)) + "].ModelScale", c_playerAny);

}



fixed libCore_gf_DataMountGetMountWalkAnimSpeedAtConfigIndex (int lp_catalogIndex) {

    // Automatic Variable Declarations

    // Implementation

    return CatalogFieldValueGetAsFixed(c_gameCatalogConfig, "Config", "MountArray[" + IntToString((lp_catalogIndex - 1)) + "].WalkAnimMoveSpeed", c_playerAny);

}



string libCore_gf_DataMountGetMountPoseAnimGroupAtConfigIndex (int lp_catalogIndex) {

    // Automatic Variable Declarations

    // Implementation

    return CatalogFieldValueGet(c_gameCatalogConfig, "Config", "MountArray[" + IntToString((lp_catalogIndex - 1)) + "].HeroPoseAnimGroup", c_playerAny);

}



void libCore_gf_DataMountsClearMountDataAtIndex (int lp_index) {

    // Variable Declarations

    int lv_itReward;

    int lv_itActorMessage;

    int lv_itVariation;

    int lv_requiredRewardCount;

    int lv_actorMessageCount;



    // Automatic Variable Declarations

    int autoFA751073_ae;

    const int autoFA751073_ai = 1;

    int auto2B042A79_ae;

    const int auto2B042A79_ai = 1;



    // Variable Initialization



    // Implementation

    libGame_gv_players[lp_index].lv_mountData.lv_mountModelScale = 0.0;

    libGame_gv_players[lp_index].lv_mountData.lv_mountModelWalkAnimMoveSpeed = 0.0;

    libGame_gv_players[lp_index].lv_mountData.lv_mountPoseAnimGroup = "";

    libGame_gv_players[lp_index].lv_mountData.lv_mountPoseAnimGroupStatus = "";

    libGame_gv_players[lp_index].lv_mountData.lv_mountID = null;

    libGame_gv_players[lp_index].lv_mountData.lv_isFree = false;

    libGame_gv_players[lp_index].lv_mountData.lv_mountName = StringToText("");

    libGame_gv_players[lp_index].lv_mountData.lv_mountModel = null;

    libGame_gv_players[lp_index].lv_mountData.lv_noAttachedMountModel = false;

    autoFA751073_ae = libGame_gv_players[lp_index].lv_mountData.lv_requiredRewardCount;

    lv_itReward = 1;

    for ( ; ( (autoFA751073_ai >= 0 && lv_itReward <= autoFA751073_ae) || (autoFA751073_ai < 0 && lv_itReward >= autoFA751073_ae) ) ; lv_itReward += autoFA751073_ai ) {

        libGame_gv_players[lp_index].lv_mountData.lv_requiredRewardArray[lv_itReward] = null;

    }

    libGame_gv_players[lp_index].lv_mountData.lv_requiredRewardCount = 0;

    auto2B042A79_ae = libGame_gv_players[lp_index].lv_mountData.lv_actorMessageCount;

    lv_itActorMessage = 1;

    for ( ; ( (auto2B042A79_ai >= 0 && lv_itActorMessage <= auto2B042A79_ae) || (auto2B042A79_ai < 0 && lv_itActorMessage >= auto2B042A79_ae) ) ; lv_itActorMessage += auto2B042A79_ai ) {

        libGame_gv_players[lp_index].lv_mountData.lv_actorMessageArray[lv_itActorMessage] = "";

    }

    libGame_gv_players[lp_index].lv_mountData.lv_actorMessageCount = 0;

    libGame_gv_players[lp_index].lv_mountData.lv_mountSound = null;

    libGame_gv_players[lp_index].lv_mountData.lv_dismountSound = null;

    libGame_gv_players[lp_index].lv_mountData.lv_loopingSound = null;

    libGame_gv_players[lp_index].lv_mountData.lv_movingSound = null;

    libGame_gv_players[lp_index].lv_mountData.lv_stationarySound = null;

    libGame_gv_players[lp_index].lv_mountData.lv_moveStartSound = null;

    libGame_gv_players[lp_index].lv_mountData.lv_moveStopSound = null;

    libGame_gv_players[lp_index].lv_mountData.lv_turboSound = null;

    libGame_gv_players[lp_index].lv_mountData.lv_category = "";

    libGame_gv_players[lp_index].lv_mountData.lv_isMorphMount = false;

    libGame_gv_players[lp_index].lv_mountData.lv_mountUpFXActor = null;

    libGame_gv_players[lp_index].lv_mountData.lv_dismountFXActor = null;

}



void libCore_gf_DataMountsLoadMountDataIntoIndex (string lp_mountLink, fixed lp_mountModelScale, fixed lp_walkAnimMoveSpeed, string lp_poseAnimGroup, int lp_index) {

    // Variable Declarations

    int lv_itReward;

    int lv_itActorMessage;

    int lv_itVariation;

    int lv_requiredRewardCount;

    int lv_actorMessageCount;



    // Automatic Variable Declarations

    int auto310833AF_ae;

    const int auto310833AF_ai = 1;

    int autoDFF797F1_ae;

    const int autoDFF797F1_ai = 1;



    // Variable Initialization



    // Implementation

    libGame_gv_players[lp_index].lv_mountData.lv_mountModelScale = lp_mountModelScale;

    libGame_gv_players[lp_index].lv_mountData.lv_mountModelWalkAnimMoveSpeed = lp_walkAnimMoveSpeed;

    libGame_gv_players[lp_index].lv_mountData.lv_mountPoseAnimGroup = lp_poseAnimGroup;

    libGame_gv_players[lp_index].lv_mountData.lv_mountPoseAnimGroupStatus = lp_poseAnimGroup;

    libGame_gv_players[lp_index].lv_mountData.lv_mountID = lp_mountLink;

    libGame_gv_players[lp_index].lv_mountData.lv_isFree = (CatalogFieldValueGetAsInt(c_gameCatalogMount, lp_mountLink, "Flags[FreePlay]", c_playerAny) == 1);

    libGame_gv_players[lp_index].lv_mountData.lv_mountName = StringExternal(("Mount/Name/" + (lp_mountLink)));

    libGame_gv_players[lp_index].lv_mountData.lv_mountModel = (CatalogFieldValueGet(c_gameCatalogMount, lp_mountLink, "Model", c_playerAny));

    libGame_gv_players[lp_index].lv_mountData.lv_mountActor = (CatalogFieldValueGet(c_gameCatalogMount, lp_mountLink, "Actor", c_playerAny));

    libGame_gv_players[lp_index].lv_mountData.lv_noAttachedMountModel = (CatalogFieldValueGetAsInt(c_gameCatalogMount, lp_mountLink, "Attached", c_playerAny) == 0);

    lv_requiredRewardCount = CatalogFieldValueCount(c_gameCatalogMount, lp_mountLink, "RequiredRewardArray", c_playerAny);

    if ((lv_requiredRewardCount > libCore_gv_data_MaxRequiredRewards_C)) {

        TextExpressionSetToken("Param/Expression/lib_Core_CB227199", "A", StringToText((lp_mountLink)));

        TextExpressionSetToken("Param/Expression/lib_Core_CB227199", "B", IntToText(libCore_gv_data_MaxRequiredRewards_C));

        TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Core_CB227199"), true);

        return ;

    }



    libGame_gv_players[lp_index].lv_mountData.lv_requiredRewardCount = lv_requiredRewardCount;

    auto310833AF_ae = lv_requiredRewardCount;

    lv_itReward = 1;

    for ( ; ( (auto310833AF_ai >= 0 && lv_itReward <= auto310833AF_ae) || (auto310833AF_ai < 0 && lv_itReward >= auto310833AF_ae) ) ; lv_itReward += auto310833AF_ai ) {

        libGame_gv_players[lp_index].lv_mountData.lv_requiredRewardArray[lv_itReward] = (CatalogFieldValueGet(c_gameCatalogMount, lp_mountLink, "RequiredRewardArray[" + IntToString((lv_itReward - 1)) + "]", c_playerAny));

    }

    lv_actorMessageCount = CatalogFieldValueCount(c_gameCatalogMount, lp_mountLink, "CreationActorMessageArray", c_playerAny);

    if ((lv_actorMessageCount > libCore_gv_dataMountsMaxActorMessageCount)) {

        TextExpressionSetToken("Param/Expression/lib_Core_FEE090A2", "A", StringToText((lp_mountLink)));

        TextExpressionSetToken("Param/Expression/lib_Core_FEE090A2", "B", IntToText(libCore_gv_dataMountsMaxActorMessageCount));

        TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Core_FEE090A2"), true);

        return ;

    }



    libGame_gv_players[lp_index].lv_mountData.lv_actorMessageCount = lv_actorMessageCount;

    autoDFF797F1_ae = lv_actorMessageCount;

    lv_itActorMessage = 1;

    for ( ; ( (autoDFF797F1_ai >= 0 && lv_itActorMessage <= autoDFF797F1_ae) || (autoDFF797F1_ai < 0 && lv_itActorMessage >= autoDFF797F1_ae) ) ; lv_itActorMessage += autoDFF797F1_ai ) {

        if ((CatalogFieldValueGetAsInt(c_gameCatalogMount, lp_mountLink, "CreationActorMessageArray[" + IntToString((lv_itActorMessage - 1)) + "].Context", c_playerAny) != (c_variationContextHeroCutscene))) {

            libGame_gv_players[lp_index].lv_mountData.lv_actorMessageArray[lv_itActorMessage] = CatalogFieldValueGet(c_gameCatalogMount, lp_mountLink, "CreationActorMessageArray[" + IntToString((lv_itActorMessage - 1)) + "].Send", c_playerAny);

        }



    }

    libGame_gv_players[lp_index].lv_mountData.lv_mountSound = (CatalogFieldValueGet(c_gameCatalogMount, lp_mountLink, "VOArray[Mounted]", c_playerAny));

    libGame_gv_players[lp_index].lv_mountData.lv_dismountSound = (CatalogFieldValueGet(c_gameCatalogMount, lp_mountLink, "VOArray[Dismounted]", c_playerAny));

    libGame_gv_players[lp_index].lv_mountData.lv_loopingSound = (CatalogFieldValueGet(c_gameCatalogMount, lp_mountLink, "VOArray[Looping]", c_playerAny));

    libGame_gv_players[lp_index].lv_mountData.lv_movingSound = (CatalogFieldValueGet(c_gameCatalogMount, lp_mountLink, "VOArray[Moving]", c_playerAny));

    libGame_gv_players[lp_index].lv_mountData.lv_stationarySound = (CatalogFieldValueGet(c_gameCatalogMount, lp_mountLink, "VOArray[Stationary]", c_playerAny));

    libGame_gv_players[lp_index].lv_mountData.lv_moveStartSound = (CatalogFieldValueGet(c_gameCatalogMount, lp_mountLink, "VOArray[StartMoving]", c_playerAny));

    libGame_gv_players[lp_index].lv_mountData.lv_moveStopSound = (CatalogFieldValueGet(c_gameCatalogMount, lp_mountLink, "VOArray[StopMoving]", c_playerAny));

    libGame_gv_players[lp_index].lv_mountData.lv_turboSound = (CatalogFieldValueGet(c_gameCatalogMount, lp_mountLink, "VOArray[Turbo]", c_playerAny));

    libGame_gv_players[lp_index].lv_mountData.lv_category = CatalogFieldValueGet(c_gameCatalogMount, lp_mountLink, "MountCategory", c_playerAny);

    if ((CatalogFieldValueGetAsInt(c_gameCatalogMount, lp_mountLink, "Flags[IsMorphMount]", c_playerAny) == 1)) {

        libGame_gv_players[lp_index].lv_mountData.lv_isMorphMount = true;

    }



    if ((CatalogEntryIsValid(c_gameCatalogActor, (((libGame_gv_players[lp_index].lv_mountData.lv_mountModel) + "CustomMountUpFX"))) == true)) {

        libGame_gv_players[lp_index].lv_mountData.lv_mountUpFXActor = (((libGame_gv_players[lp_index].lv_mountData.lv_mountModel) + "CustomMountUpFX"));

    }

    else {

        libGame_gv_players[lp_index].lv_mountData.lv_mountUpFXActor = "MountSmokeScreen";

    }

    if ((CatalogEntryIsValid(c_gameCatalogActor, (((libGame_gv_players[lp_index].lv_mountData.lv_mountModel) + "CustomDismountFX"))) == true)) {

        libGame_gv_players[lp_index].lv_mountData.lv_dismountFXActor = (((libGame_gv_players[lp_index].lv_mountData.lv_mountModel) + "CustomDismountFX"));

    }

    else {

        libGame_gv_players[lp_index].lv_mountData.lv_dismountFXActor = "DismountSmokeScreen";

    }

}



void libCore_gf_DataMountsAddMountIDToDataTable (string lp_mountLink, int lp_catalogIndex, int lp_variationRefIndex) {

    // Variable Declarations

    int lv_itVariation;

    string lv_mountLinkStr;

    string lv_mountDataTableStr;

    string lv_mountCategoryStr;

    string lv_mountCategoryCountStr;



    // Automatic Variable Declarations

    int autoE8F7E14F_ae;

    const int autoE8F7E14F_ai = 1;



    // Variable Initialization

    lv_mountLinkStr = "";

    lv_mountDataTableStr = "";

    lv_mountCategoryStr = "";

    lv_mountCategoryCountStr = "";



    // Implementation

    lv_mountLinkStr = (lp_mountLink);

    lv_mountCategoryStr = CatalogFieldValueGet(c_gameCatalogMount, lp_mountLink, "MountCategory", c_playerAny);

    lv_mountCategoryCountStr = ("Mounts_MountCategory_" + lv_mountCategoryStr + "_MountCount");

    libCore_gv_dataMountsMountCount += 1;

    DataTableSetInt(true, "Mounts_MountCount", libCore_gv_dataMountsMountCount);

    DataTableSetInt(true, lv_mountCategoryCountStr, (DataTableGetInt(true, lv_mountCategoryCountStr) + 1));

    lv_mountDataTableStr = ("Mounts_MountCategory_" + lv_mountCategoryStr + "_Index_" + IntToString(DataTableGetInt(true, lv_mountCategoryCountStr)));

    DataTableSetString(true, (lv_mountDataTableStr + "_ID"), lv_mountLinkStr);

    DataTableSetInt(true, (lv_mountDataTableStr + "_Index"), libCore_gv_dataMountsMountCount);

    DataTableSetInt(true, (lv_mountDataTableStr + "_CatalogIndex"), lp_catalogIndex);

    DataTableSetInt(true, (lv_mountDataTableStr + "_VariationRefIndex"), lp_variationRefIndex);

    DataTableSetString(true, ("MountIndex_" + IntToString(libCore_gv_dataMountsMountCount)), lv_mountLinkStr);

    autoE8F7E14F_ae = (CatalogFieldValueCount(c_gameCatalogMount, lp_mountLink, "VariationArray", c_playerAny) - 1);

    lv_itVariation = 0;

    for ( ; ( (autoE8F7E14F_ai >= 0 && lv_itVariation <= autoE8F7E14F_ae) || (autoE8F7E14F_ai < 0 && lv_itVariation >= autoE8F7E14F_ae) ) ; lv_itVariation += autoE8F7E14F_ai ) {

        libCore_gf_DataMountsAddMountIDToDataTable((CatalogFieldValueGet(c_gameCatalogMount, lp_mountLink, "VariationArray[" + IntToString(lv_itVariation) + "]", c_playerAny)), lp_catalogIndex, lp_catalogIndex);

    }

}



void libCore_gf_SendMountActorMessagesToActor (int lp_mountIndex, actor lp_actor) {

    // Variable Declarations

    int lv_itActorMessage;



    // Automatic Variable Declarations

    int auto3868F64B_ae;

    const int auto3868F64B_ai = 1;



    // Variable Initialization



    // Implementation

    auto3868F64B_ae = libGame_gv_players[lp_mountIndex].lv_mountData.lv_actorMessageCount;

    lv_itActorMessage = 1;

    for ( ; ( (auto3868F64B_ai >= 0 && lv_itActorMessage <= auto3868F64B_ae) || (auto3868F64B_ai < 0 && lv_itActorMessage >= auto3868F64B_ae) ) ; lv_itActorMessage += auto3868F64B_ai ) {

        ActorSend(lp_actor, (libGame_gv_players[lp_mountIndex].lv_mountData.lv_actorMessageArray[lv_itActorMessage]));

    }

}



fixed libCore_gf_HeroDeathTime (int lp_player, int lp_level) {

    // Variable Declarations

    fixed lv_deathTime;



    // Automatic Variable Declarations

    // Variable Initialization



    // Implementation

    if (((lp_player < 0) || (lp_player > libCore_gv_bALMaxPlayers) || (lp_level < 1) || (lp_level > libCore_gv_bALMaxLevel))) {

        TextExpressionSetToken("Param/Expression/lib_Core_59E44F20", "A", IntToText(lp_player));

        TextExpressionSetToken("Param/Expression/lib_Core_59E44F20", "B", IntToText(lp_level));

        TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Core_59E44F20"), true);

        return 0;

    }



    if ((libCore_gv_bALDeathTimeOverride != 0.0)) {

        return libCore_gv_bALDeathTimeOverride;

    }



    if ((libCore_gv_brettTimersEnabled == true)) {

        lv_deathTime = (libCore_gv_bALDeathTimes[lp_level] + libGame_gv_players[lp_player].lv_brettTimersTimeMod);

        if ((lv_deathTime < libCore_gv_brettTimersMinimumTimer)) {

            lv_deathTime = libCore_gv_brettTimersMinimumTimer;

        }



        if ((lv_deathTime > libCore_gv_brettTimersMaximumTimer)) {

            lv_deathTime = libCore_gv_brettTimersMaximumTimer;

        }



    }

    else {

        lv_deathTime = (libCore_gv_bALDeathTimes[lp_level] * libCore_gv_bALDeathTimeScaler);

    }

    if ((libCore_gv_sYSDeathTimerCap > 0.0)) {

        lv_deathTime = MinF(lv_deathTime, libCore_gv_sYSDeathTimerCap);

    }



    if ((lp_player == libCore_gv_cOMPUTER_Neutral)) {

        return lv_deathTime;

    }



    if ((lp_player == 1) && (libCore_gv_sYSGameMode == libCore_ge_GameModes_Tutorial1)) {

        lv_deathTime = MinF(MaxF(7.0, (lv_deathTime / 2.0)), 15.0);

    }

    else if ((lp_player == 1) && (libCore_gv_sYSGameMode == libCore_ge_GameModes_TutorialMapMechanics)) {

        lv_deathTime = MinF(MaxF(7.0, (lv_deathTime / 2.0)), 20.0);

    }

    else if ((libStEx_gf_GameIsSinglePlayer() == true) && ((libStEx_gf_InTrainingMode() == true) || (libStEx_gf_InPracticeMode() == true)) && (PlayerType(lp_player) == c_playerTypeUser)) {

        lv_deathTime = MinF(lv_deathTime, 30.0);

    }

    else if (((libCore_gv_sYSGameMode == libCore_ge_GameModes_ArenaMode) || (libCore_gv_sYSGameMode == libCore_ge_GameModes_AttackDefend))) {

        lv_deathTime = MinF(lv_deathTime, 15.0);

    }

    return lv_deathTime;

}



void libCore_gf_RegisterSegregationTrigger (int lp_type, trigger lp_trigger) {

    // Variable Declarations

    int lv_index;



    // Automatic Variable Declarations

    int autoC217AED1_ae;



    // Variable Initialization



    // Implementation

    autoC217AED1_ae = libCore_gv_segregationTriggerCountPerType;

    lv_index = 0;

    for ( ; lv_index <= autoC217AED1_ae ; lv_index += 1 ) {

        if ((libCore_gv_segregationTriggers[(lp_type)][lv_index] == lp_trigger)) {

            return ;

        }



        if ((libCore_gv_segregationTriggers[(lp_type)][lv_index] == null)) {

            libCore_gv_segregationTriggers[(lp_type)][lv_index] = lp_trigger;

            return ;

        }



    }

    TextExpressionSetToken("Param/Expression/lib_Core_FB85844B", "A", StringToText(libCore_ge_SegregationTriggerTypes_Ident(lp_type)));

    TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Core_FB85844B"), true);

}



void libCore_gf_CallRegisteredSegregationTriggers (int lp_type) {

    // Variable Declarations

    int lv_index;



    // Automatic Variable Declarations

    int autoD01536E6_ae;



    // Variable Initialization



    // Implementation

    autoD01536E6_ae = libCore_gv_segregationTriggerCountPerType;

    lv_index = 0;

    for ( ; lv_index <= autoD01536E6_ae ; lv_index += 1 ) {

        if ((libCore_gv_segregationTriggers[(lp_type)][lv_index] != null)) {

            TriggerExecute(libCore_gv_segregationTriggers[(lp_type)][lv_index], true, true);

        }

        else {

            break;

        }

    }

    libCore_gv_segTriggerPlayer = 0;

    libCore_gv_segTriggerUnit = null;

    libCore_gv_segTriggerPoint = null;

    libCore_gv_segTriggerIndex = 0;

}



string libCore_gf_DataSkinsGetSkinLinkFromSkinCatalogIndex (int lp_index) {

    // Automatic Variable Declarations

    // Implementation

    return (DataTableGetString(true, ("SkinIndex_" + IntToString(lp_index))));

}



int libCore_gf_DataSkinsGetSkinIndexFromSkinLink (string lp_skinLink) {

    // Variable Declarations

    int lv_itSkin;



    // Automatic Variable Declarations

    int auto590EFA94_ae;

    const int auto590EFA94_ai = 1;



    // Variable Initialization



    // Implementation

    auto590EFA94_ae = libCore_gv_dataSkinsSkinCount;

    lv_itSkin = 1;

    for ( ; ( (auto590EFA94_ai >= 0 && lv_itSkin <= auto590EFA94_ae) || (auto590EFA94_ai < 0 && lv_itSkin >= auto590EFA94_ae) ) ; lv_itSkin += auto590EFA94_ai ) {

        if ((lp_skinLink == libCore_gf_DataSkinsGetSkinLinkFromSkinCatalogIndex(lv_itSkin))) {

            return lv_itSkin;

        }



    }

    return 0;

}



bool libCore_gf_DataSkinsIsSkinValidForHero (int lp_heroIndex, int lp_skinIndex) {

    // Variable Declarations

    int lv_itSkin;

    string lv_skinLink;



    // Automatic Variable Declarations

    int autoB7F44AA0_ae;

    const int autoB7F44AA0_ai = 1;



    // Variable Initialization



    // Implementation

    lv_skinLink = libCore_gf_DataSkinsGetSkinLinkFromSkinCatalogIndex(lp_skinIndex);

    autoB7F44AA0_ae = libGame_gv_players[lp_heroIndex].lv_heroData.lv_skinCount;

    lv_itSkin = 1;

    for ( ; ( (autoB7F44AA0_ai >= 0 && lv_itSkin <= autoB7F44AA0_ae) || (autoB7F44AA0_ai < 0 && lv_itSkin >= autoB7F44AA0_ae) ) ; lv_itSkin += autoB7F44AA0_ai ) {

        if ((libGame_gv_players[lp_heroIndex].lv_heroData.lv_skinArray[lv_itSkin] == lv_skinLink)) {

            return true;

        }



    }

    return false;

}



void libCore_gf_DataClearSkinDataAtIndex (int lp_index) {

    // Variable Declarations

    int lv_itSkin;

    int lv_itReward;

    int lv_itActorMessage;

    int lv_itMountCategory;

    string lv_skinID;

    int lv_requiredRewardCount;

    int lv_actorMessageCount;



    // Automatic Variable Declarations

    int auto89FE7469_ae;

    const int auto89FE7469_ai = 1;

    int autoE8A4A82B_ae;

    const int autoE8A4A82B_ai = 1;

    int autoE10038C4_ae;

    const int autoE10038C4_ai = 1;



    // Variable Initialization

    lv_skinID = "";



    // Implementation

    libGame_gv_players[lp_index].lv_skinData.lv_skinID = null;

    libGame_gv_players[lp_index].lv_skinData.lv_skinName = StringToText("");

    auto89FE7469_ae = libGame_gv_players[lp_index].lv_skinData.lv_requiredRewardCount;

    lv_itReward = 1;

    for ( ; ( (auto89FE7469_ai >= 0 && lv_itReward <= auto89FE7469_ae) || (auto89FE7469_ai < 0 && lv_itReward >= auto89FE7469_ae) ) ; lv_itReward += auto89FE7469_ai ) {

        libGame_gv_players[lp_index].lv_skinData.lv_requiredRewardArray[lv_itReward] = null;

    }

    libGame_gv_players[lp_index].lv_skinData.lv_requiredRewardCount = 0;

    autoE8A4A82B_ae = libGame_gv_players[lp_index].lv_skinData.lv_actorMessageCount;

    lv_itActorMessage = 1;

    for ( ; ( (autoE8A4A82B_ai >= 0 && lv_itActorMessage <= autoE8A4A82B_ae) || (autoE8A4A82B_ai < 0 && lv_itActorMessage >= autoE8A4A82B_ae) ) ; lv_itActorMessage += autoE8A4A82B_ai ) {

        libGame_gv_players[lp_index].lv_skinData.lv_actorMessageArray[lv_itActorMessage] = "";

    }

    libGame_gv_players[lp_index].lv_skinData.lv_actorMessageCount = 0;

    autoE10038C4_ae = libGame_gv_players[lp_index].lv_skinData.lv_allowedMountCategoryCount;

    lv_itMountCategory = 1;

    for ( ; ( (autoE10038C4_ai >= 0 && lv_itMountCategory <= autoE10038C4_ae) || (autoE10038C4_ai < 0 && lv_itMountCategory >= autoE10038C4_ae) ) ; lv_itMountCategory += autoE10038C4_ai ) {

        libGame_gv_players[lp_index].lv_skinData.lv_allowedMountCategories[lv_itMountCategory] = "";

    }

    libGame_gv_players[lp_index].lv_skinData.lv_allowedMountCategoryCount = 0;

}



void libCore_gf_DataLoadSkinDataIntoIndex (string lp_skinLink, int lp_index) {

    // Variable Declarations

    int lv_itSkin;

    int lv_itReward;

    int lv_itActorMessage;

    int lv_itMountCategory;

    string lv_skinID;

    int lv_requiredRewardCount;

    int lv_actorMessageCount;



    // Automatic Variable Declarations

    int auto1E6B7405_ae;

    const int auto1E6B7405_ai = 1;

    int auto89E253BA_ae;

    const int auto89E253BA_ai = 1;

    int auto6AACAFE1_ae;

    const int auto6AACAFE1_ai = 1;



    // Variable Initialization

    lv_skinID = "";



    // Implementation

    if ((lp_skinLink == null)) {

        TriggerDebugOutput(1, StringExternal("Param/Value/lib_Core_E823B4F4"), true);

        return ;

    }



    lv_skinID = (lp_skinLink);

    if ((lv_skinID == "Default")) {

        libGame_gv_players[lp_index].lv_skinData.lv_skinID = ("Default");

        libGame_gv_players[lp_index].lv_skinData.lv_skinName = StringExternal("Param/Value/lib_Core_C3F0C398");

        libGame_gv_players[lp_index].lv_skinData.lv_requiredRewardCount = 0;

        return ;

    }



    libGame_gv_players[lp_index].lv_skinData.lv_skinID = lp_skinLink;

    libGame_gv_players[lp_index].lv_skinData.lv_skinName = StringExternal(("Skin/Name/" + lv_skinID));

    lv_requiredRewardCount = CatalogFieldValueCount(c_gameCatalogSkin, lv_skinID, "RequiredRewardArray", c_playerAny);

    libGame_gv_players[lp_index].lv_skinData.lv_requiredRewardCount = lv_requiredRewardCount;

    auto1E6B7405_ae = lv_requiredRewardCount;

    lv_itReward = 1;

    for ( ; ( (auto1E6B7405_ai >= 0 && lv_itReward <= auto1E6B7405_ae) || (auto1E6B7405_ai < 0 && lv_itReward >= auto1E6B7405_ae) ) ; lv_itReward += auto1E6B7405_ai ) {

        libGame_gv_players[lp_index].lv_skinData.lv_requiredRewardArray[lv_itReward] = (CatalogFieldValueGet(c_gameCatalogSkin, lv_skinID, "RequiredRewardArray[" + IntToString((lv_itReward - 1)) + "]", c_playerAny));

    }

    lv_actorMessageCount = CatalogFieldValueCount(c_gameCatalogSkin, lv_skinID, "CreationActorMessageArray", c_playerAny);

    if ((lv_actorMessageCount > libCore_gv_dataSkinsMaxActorMessageCount)) {

        TextExpressionSetToken("Param/Expression/lib_Core_315DE641", "A", StringToText(lv_skinID));

        TextExpressionSetToken("Param/Expression/lib_Core_315DE641", "B", IntToText(libCore_gv_dataSkinsMaxActorMessageCount));

        TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Core_315DE641"), true);

        return ;

    }



    libGame_gv_players[lp_index].lv_skinData.lv_actorMessageCount = lv_actorMessageCount;

    auto89E253BA_ae = lv_actorMessageCount;

    lv_itActorMessage = 1;

    for ( ; ( (auto89E253BA_ai >= 0 && lv_itActorMessage <= auto89E253BA_ae) || (auto89E253BA_ai < 0 && lv_itActorMessage >= auto89E253BA_ae) ) ; lv_itActorMessage += auto89E253BA_ai ) {

        if ((CatalogFieldValueGetAsInt(c_gameCatalogSkin, lv_skinID, "CreationActorMessageArray[" + IntToString((lv_itActorMessage - 1)) + "].Context", c_playerAny) != (c_variationContextHeroCutscene))) {

            libGame_gv_players[lp_index].lv_skinData.lv_actorMessageArray[lv_itActorMessage] = CatalogFieldValueGet(c_gameCatalogSkin, lv_skinID, "CreationActorMessageArray[" + IntToString((lv_itActorMessage - 1)) + "].Send", c_playerAny);

        }



    }

    libGame_gv_players[lp_index].lv_skinData.lv_allowedMountCategoryCount = CatalogFieldValueCount(c_gameCatalogSkin, lv_skinID, "AdditionalMountCategoryArray", c_playerAny);

    if ((libGame_gv_players[lp_index].lv_skinData.lv_allowedMountCategoryCount > libCore_gv_data_MaxSkinAllowedMountCategories_C)) {

        TextExpressionSetToken("Param/Expression/lib_Core_894723D0", "A", StringToText(lv_skinID));

        TextExpressionSetToken("Param/Expression/lib_Core_894723D0", "B", IntToText(libCore_gv_data_MaxSkinAllowedMountCategories_C));

        TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Core_894723D0"), true);

        libGame_gv_players[lp_index].lv_skinData.lv_allowedMountCategoryCount = libCore_gv_data_MaxSkinAllowedMountCategories_C;

    }



    auto6AACAFE1_ae = libGame_gv_players[lp_index].lv_skinData.lv_allowedMountCategoryCount;

    lv_itMountCategory = 1;

    for ( ; ( (auto6AACAFE1_ai >= 0 && lv_itMountCategory <= auto6AACAFE1_ae) || (auto6AACAFE1_ai < 0 && lv_itMountCategory >= auto6AACAFE1_ae) ) ; lv_itMountCategory += auto6AACAFE1_ai ) {

        libGame_gv_players[lp_index].lv_skinData.lv_allowedMountCategories[lv_itMountCategory] = CatalogFieldValueGet(c_gameCatalogSkin, lv_skinID, "AdditionalMountCategoryArray[" + IntToString((lv_itMountCategory - 1)) + "]", c_playerAny);

    }

}



void libCore_gf_SendPlayersSkinActorMessagesToUnit (int lp_player, unit lp_unit) {

    // Variable Declarations

    int lv_itActorMessage;

    int lv_skinIndex;

    actor lv_unitActor;



    // Automatic Variable Declarations

    int auto33A2EE0F_ae;

    const int auto33A2EE0F_ai = 1;



    // Variable Initialization



    // Implementation

    lv_unitActor = libNtve_gf_MainActorofUnit(lp_unit);

    auto33A2EE0F_ae = libGame_gv_players[lp_player].lv_skinData.lv_actorMessageCount;

    lv_itActorMessage = 1;

    for ( ; ( (auto33A2EE0F_ai >= 0 && lv_itActorMessage <= auto33A2EE0F_ae) || (auto33A2EE0F_ai < 0 && lv_itActorMessage >= auto33A2EE0F_ae) ) ; lv_itActorMessage += auto33A2EE0F_ai ) {

        ActorSend(lv_unitActor, (libGame_gv_players[lp_player].lv_skinData.lv_actorMessageArray[lv_itActorMessage]));

    }

}



void libCore_gf_SendSkinActorMessagesToUnit (string lp_skin, unit lp_unit) {

    // Variable Declarations

    int lv_itActorMessage;

    int lv_skinIndex;

    actor lv_unitActor;



    // Automatic Variable Declarations

    int auto177D448F_ae;

    const int auto177D448F_ai = 1;



    // Variable Initialization



    // Implementation

    lv_skinIndex = libCore_gf_DataSkinsGetSkinIndexFromSkinLink(lp_skin);

    lv_unitActor = libNtve_gf_MainActorofUnit(lp_unit);

    auto177D448F_ae = libGame_gv_players[lv_skinIndex].lv_skinData.lv_actorMessageCount;

    lv_itActorMessage = 1;

    for ( ; ( (auto177D448F_ai >= 0 && lv_itActorMessage <= auto177D448F_ae) || (auto177D448F_ai < 0 && lv_itActorMessage >= auto177D448F_ae) ) ; lv_itActorMessage += auto177D448F_ai ) {

        ActorSend(lv_unitActor, (libGame_gv_players[lv_skinIndex].lv_skinData.lv_actorMessageArray[lv_itActorMessage]));

    }

}



void libCore_gf_SetTalentsTierLevels (int lp_player) {

    // Variable Declarations

    int lv_itTier;



    // Automatic Variable Declarations

    const int autoEE7F0FF9_ae = libCore_gv_talents_MaxTiers_C;

    const int autoEE7F0FF9_ai = 1;



    // Variable Initialization

    lv_itTier = 1;



    // Implementation

    lv_itTier = 1;

    for ( ; ( (autoEE7F0FF9_ai >= 0 && lv_itTier <= autoEE7F0FF9_ae) || (autoEE7F0FF9_ai < 0 && lv_itTier >= autoEE7F0FF9_ae) ) ; lv_itTier += autoEE7F0FF9_ai ) {

        libGame_gv_players[lp_player].lv_talents_TierLevels[lv_itTier].lv_level = CatalogFieldValueGetAsInt(c_gameCatalogHero, PlayerHero(lp_player), "TalentTierArray[" + IntToString((lv_itTier-1)) + "].Level", lp_player);

    }

}



void libCore_gf_SetHeroicTalentTier (int lp_player) {

    // Variable Declarations

    int lv_itTier;



    // Automatic Variable Declarations

    int auto4418CAF4_ae;



    // Variable Initialization

    lv_itTier = 1;



    // Implementation

    auto4418CAF4_ae = libCore_gv_talents_MaxTiers_C;

    lv_itTier = 1;

    for ( ; lv_itTier <= auto4418CAF4_ae ; lv_itTier += 1 ) {

        if ((CatalogFieldValueGetAsInt(c_gameCatalogHero, PlayerHero(lp_player), "TalentTierArray[" + IntToString((lv_itTier-1)) + "].ContainsHeroic", c_playerAny) == 1)) {

            libGame_gv_players[lp_player].lv_talent_HeroicTalentTier = lv_itTier;

            break;

        }



    }

}



int libCore_gf_DataXPLevelGapBetweenHeroes (int lp_awardPlayer, unit lp_deadUnit) {

    // Variable Declarations

    int lv_levelOfAwardPlayer;

    int lv_deadUnitOwner;

    int lv_levelOfDeadPlayer;



    // Automatic Variable Declarations

    // Variable Initialization



    // Implementation

    lv_levelOfAwardPlayer = UnitLevel(libGame_gv_players[lp_awardPlayer].lv_heroUnit);

    lv_deadUnitOwner = UnitGetOwner(lp_deadUnit);

    if ((lv_deadUnitOwner > libCore_gv_bALMaxEnginePlayerCount)) {

        TextExpressionSetToken("Param/Expression/lib_Core_A1B06F31", "A", IntToText(lp_awardPlayer));

        TextExpressionSetToken("Param/Expression/lib_Core_A1B06F31", "B", UnitTypeGetName(UnitGetType(lp_deadUnit)));

        TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Core_A1B06F31"), true);

        return 0;

    }



    lv_levelOfDeadPlayer = UnitLevel(libGame_gv_players[lv_deadUnitOwner].lv_heroUnit);

    return (lv_levelOfDeadPlayer - lv_levelOfAwardPlayer);

}



fixed libCore_gf_DataXPGetMoreGranularBountyXPModifier (unit lp_deadHero, unit lp_playerHero) {

    // Variable Declarations

    int lv_deadHeroWholeLevel;

    fixed lv_deadHeroLevelProgress;

    fixed lv_deadHeroLevelCombined;

    int lv_playerHeroWholeLevel;

    fixed lv_playerHeroLevelProgress;

    fixed lv_playerHeroLevelCombined;

    int lv_playerTeam;

    int lv_enemyTeam;

    fixed lv_xPMath;

    fixed lv_levelDifferenceReal;

    fixed lv_levelDifferenceTrunc;

    fixed lv_levelDifferenceModulo;

    bool lv_isNegative;

    fixed lv_experienceLevelBaseXP;

    fixed lv_experienceLevelTotalXP;

    int lv_experienceLevelBase1XP;

    fixed lv_levelDifferenceModuloPostCalc;

    fixed lv_truncMod;

    fixed lv_moduloMod;

    fixed lv_combinedMod;

    fixed lv_finalMod;



    // Automatic Variable Declarations

    // Variable Initialization



    // Implementation

    if ((libCore_gv_sYSGameMode == libCore_ge_GameModes_TryMe)) {

        return 1.0;

    }



    if (((UnitGetOwner(lp_playerHero) < 1) || (UnitGetOwner(lp_playerHero) > libCore_gv_bALMaxPlayers))) {

        if ((libCore_gv_sYSGameMode != libCore_ge_GameModes_Tutorial1Deprecated) && (libCore_gv_sYSGameMode != libCore_ge_GameModes_TutorialVeteran)) {

            TextExpressionSetToken("Param/Expression/lib_Core_596ADF72", "A", IntToText(UnitGetOwner(lp_playerHero)));

            TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Core_596ADF72"), true);

        }



        return 1.0;

    }



    lv_deadHeroWholeLevel = UnitXPGetCurrentLevel(libGame_gv_players[UnitGetOwner(lp_deadHero)].lv_heroUnit, "HeroDummyVeterancy");

    lv_experienceLevelBaseXP = libCore_gf_GetTotalXPForLevel(lv_deadHeroWholeLevel);

    lv_experienceLevelTotalXP = UnitXPGetCurrentXP(libGame_gv_players[UnitGetOwner(lp_deadHero)].lv_heroUnit, "HeroDummyVeterancy");

    lv_experienceLevelBase1XP = (lv_deadHeroWholeLevel + 1);

    lv_xPMath = (libCore_gf_GetTotalXPForLevel(lv_experienceLevelBase1XP) - lv_experienceLevelBaseXP);

    if ((lv_xPMath != 0.0)) {

        lv_deadHeroLevelProgress = ((lv_experienceLevelTotalXP - lv_experienceLevelBaseXP) / (libCore_gf_GetTotalXPForLevel(lv_experienceLevelBase1XP) - lv_experienceLevelBaseXP));

    }

    else {

        lv_deadHeroLevelProgress = 0.0;

    }

    lv_deadHeroLevelCombined = (IntToFixed(lv_deadHeroWholeLevel) + lv_deadHeroLevelProgress);

    if ((libCore_gv_dataXPGranularBountyXPMathDisplayEnabled == true)) {

        TriggerDebugOutput(1, (StringExternal("Param/Value/lib_Core_983035AE") + FixedToText(lv_deadHeroLevelCombined, 3)), true);

    }



    lv_playerHeroWholeLevel = UnitXPGetCurrentLevel(libGame_gv_players[UnitGetOwner(lp_playerHero)].lv_heroUnit, "HeroDummyVeterancy");

    lv_experienceLevelBaseXP = libCore_gf_GetTotalXPForLevel(lv_playerHeroWholeLevel);

    lv_experienceLevelTotalXP = UnitXPGetCurrentXP(libGame_gv_players[UnitGetOwner(lp_playerHero)].lv_heroUnit, "HeroDummyVeterancy");

    lv_experienceLevelBase1XP = (lv_playerHeroWholeLevel + 1);

    lv_xPMath = (libCore_gf_GetTotalXPForLevel(lv_experienceLevelBase1XP) - lv_experienceLevelBaseXP);

    if ((lv_xPMath != 0.0)) {

        lv_playerHeroLevelProgress = ((lv_experienceLevelTotalXP - lv_experienceLevelBaseXP) / (libCore_gf_GetTotalXPForLevel(lv_experienceLevelBase1XP) - lv_experienceLevelBaseXP));

    }

    else {

        lv_playerHeroLevelProgress = 0.0;

    }

    lv_playerHeroLevelCombined = (IntToFixed(lv_playerHeroWholeLevel) + lv_playerHeroLevelProgress);

    if ((libCore_gv_dataXPGranularBountyXPMathDisplayEnabled == true)) {

        TriggerDebugOutput(1, (StringExternal("Param/Value/lib_Core_5631D66E") + FixedToText(lv_playerHeroLevelCombined, 3)), true);

    }



    lv_playerTeam = libGame_gf_TeamNumberOfPlayer(UnitGetOwner(lp_playerHero));

    lv_enemyTeam = libGame_gf_TeamNumberOfPlayer(UnitGetOwner(lp_deadHero));

    lv_levelDifferenceReal = (lv_deadHeroLevelCombined - lv_playerHeroLevelCombined);

    if ((libCore_gv_dataXPGranularBountyXPMathDisplayEnabled == true)) {

        TriggerDebugOutput(1, (StringExternal("Param/Value/lib_Core_E14A0605") + FixedToText(lv_levelDifferenceReal, 3)), true);

    }



    if ((lv_levelDifferenceReal < 0.0)) {

        lv_isNegative = true;

    }



    if ((lv_levelDifferenceReal > -1.0) && (lv_levelDifferenceReal < 1.0)) {

        lv_levelDifferenceTrunc = 0.0;

    }

    else {

        lv_levelDifferenceTrunc = AbsF(Trunc(lv_levelDifferenceReal));

    }

    lv_levelDifferenceModulo = AbsF(ModF(lv_levelDifferenceReal, 1.0));

    lv_levelDifferenceModuloPostCalc = (lv_levelDifferenceModulo * 0.1);

    if ((lv_levelDifferenceTrunc == 0.0)) {

        lv_truncMod = 0.0;

        lv_moduloMod = 1.0;

    }

    else if ((lv_levelDifferenceTrunc == 1)) {

        lv_truncMod = 0.1;

        lv_moduloMod = 2.0;

    }

    else if ((lv_levelDifferenceTrunc == 2.0)) {

        lv_truncMod = 0.35;

        lv_moduloMod = 3.0;

    }

    else if ((lv_levelDifferenceTrunc == 3.0)) {

        lv_truncMod = 0.75;

        lv_moduloMod = 4.0;

    }

    else if ((lv_levelDifferenceTrunc == 4.0)) {

        lv_truncMod = 1.3;

        lv_moduloMod = 5.0;

    }

    else if ((lv_levelDifferenceTrunc >= 5.0)) {

        lv_truncMod = 2.0;

        lv_moduloMod = 0.0;

    }

    if ((libCore_gv_dataXPGranularBountyXPMathDisplayEnabled == true)) {

        TriggerDebugOutput(1, (StringExternal("Param/Value/lib_Core_2FAE8198") + FixedToText(lv_truncMod, 3)), true);

    }



    if ((libCore_gv_dataXPGranularBountyXPMathDisplayEnabled == true)) {

        TriggerDebugOutput(1, (StringExternal("Param/Value/lib_Core_91E4851A") + FixedToText((lv_levelDifferenceModuloPostCalc * lv_moduloMod), 3)), true);

    }



    lv_combinedMod = (lv_truncMod + (lv_levelDifferenceModuloPostCalc * lv_moduloMod));

    if ((libCore_gv_dataXPGranularBountyXPMathDisplayEnabled == true)) {

        TriggerDebugOutput(1, (StringToText("") + FixedToText(lv_combinedMod, 3)), true);

    }



    if ((lv_isNegative == true)) {

        lv_combinedMod = (lv_combinedMod * libCore_gv_data_XP_CatchUpXPPunishmentScaler);

        lv_combinedMod = (1.0 - lv_combinedMod);

    }

    else {

        lv_combinedMod = (lv_combinedMod * libCore_gv_data_XP_CatchUpXPBonusScaler);

        lv_combinedMod = (lv_combinedMod + 1.0);

    }

    if ((libCore_gv_dataXPGranularBountyXPMathDisplayEnabled == true)) {

        TriggerDebugOutput(1, (StringExternal("Param/Value/lib_Core_68E57718") + FixedToText(lv_combinedMod, 3)), true);

    }



    if ((lv_combinedMod >= 0.05) && (lv_combinedMod <= 3.0)) {

        lv_finalMod = lv_combinedMod;

    }

    else if ((lv_combinedMod > 3.0)) {

        lv_finalMod = 3.0;

    }

    else if ((lv_combinedMod < 0.05)) {

        lv_finalMod = 0.05;

    }

    if ((libCore_gv_dataXPGranularBountyXPMathDisplayEnabled == true)) {

        TriggerDebugOutput(1, (StringExternal("Param/Value/lib_Core_788F8763") + FixedToText(lv_finalMod, 3)), true);

    }



    return lv_finalMod;

}



fixed libCore_gf_DataXPGetValueCoefficientForUnit (unit lp_deadUnit) {

    // Automatic Variable Declarations

    // Implementation

    if ((UnitHasBehavior2(lp_deadUnit, "OneQuarterValueHero") == true)) {

        return libCore_gv_data_XP_HeroOneQuarterValueCoefficient_C;

    }



    if ((UnitHasBehavior2(lp_deadUnit, "HalfValueHero") == true)) {

        return libCore_gv_data_XP_HeroHalfValueCoefficient_C;

    }



    if ((UnitHasBehavior2(lp_deadUnit, "ThreeQuarterValueHero") == true)) {

        return libCore_gv_data_XP_HeroThreeQuarterValueCoefficient_C;

    }



    if ((UnitGetType(lp_deadUnit) == "MurkyRespawnEgg")) {

        return libCore_gv_data_XP_HeroHalfValueCoefficient_C;

    }



    return 1.0;

}



fixed libCore_gf_DataXPXPForHero (int lp_awardPlayer, unit lp_deadUnit) {

    // Variable Declarations

    unit lv_heroUnit;

    int lv_levelOfDeadPlayer;

    fixed lv_baseXP;

    fixed lv_valueCoefficient;

    fixed lv_modifierValue;

    fixed lv_finalXP;



    // Automatic Variable Declarations

    // Variable Initialization



    // Implementation

    lv_heroUnit = libGame_gv_players[UnitGetOwner(lp_deadUnit)].lv_heroUnit;

    lv_levelOfDeadPlayer = UnitLevel(lv_heroUnit);

    lv_baseXP = (libCore_gv_data_XP_HeroValuePerLevel_C * IntToFixed((lv_levelOfDeadPlayer + libCore_gv_data_XP_HeroLevelModifier_C)));

    lv_valueCoefficient = libCore_gf_DataXPGetValueCoefficientForUnit(lp_deadUnit);

    lv_baseXP *= lv_valueCoefficient;

    lv_baseXP *= libCore_gv_data_XP_HeroXPModifier[libGame_gf_TeamNumberOfPlayer(lp_awardPlayer)];

    if ((libCore_gv_dataXPGranularBountyXPMathDisplayEnabled == true)) {

        TriggerDebugOutput(1, (StringExternal("Param/Value/lib_Core_C711DF88") + FixedToText(lv_baseXP, c_fixedPrecisionAny)), true);

    }



    if ((libSprt_gv_dEBUGBonusMinionXP == false)) {

        lv_finalXP = (lv_baseXP * libCore_gf_DataXPGetMoreGranularBountyXPModifier(lp_deadUnit, libGame_gv_players[lp_awardPlayer].lv_heroUnit));

        if ((libCore_gv_dataXPGranularBountyXPMathDisplayEnabled == true)) {

            TriggerDebugOutput(1, (StringExternal("Param/Value/lib_Core_17C272A5") + FixedToText(lv_finalXP, c_fixedPrecisionAny)), true);

        }



    }

    else {

        lv_modifierValue = libCore_gf_DataXPGetMoreGranularBountyXPModifier(lp_deadUnit, libGame_gv_players[lp_awardPlayer].lv_heroUnit);

        if ((lv_modifierValue < 1)) {

            lv_finalXP = (lv_baseXP * lv_modifierValue);

        }

        else {

            lv_finalXP = lv_baseXP;

        }

    }

    return lv_finalXP;

}



fixed libCore_gf_DataXPXPForMinion (fixed lp_baseXPValue, int lp_awardPlayer, unit lp_deadUnit) {

    // Variable Declarations

    unit lv_heroUnitOfAllyofDeadUnit;

    fixed lv_modifierCoefficient;

    fixed lv_finalXP;



    // Automatic Variable Declarations

    // Variable Initialization



    // Implementation

    if ((libSprt_gv_dEBUGBonusMinionXP == true)) {

        if (((UnitGetOwner(lp_deadUnit) == libCore_gv_cOMPUTER_TeamChaos) || (UnitGetOwner(lp_deadUnit) == libCore_gv_cOMPUTER_TeamOrder))) {

            lv_heroUnitOfAllyofDeadUnit = libGame_gv_players[PlayerGroupPlayer(PlayerGroupAlliance(c_playerGroupAlly, UnitGetOwner(lp_deadUnit)), 1)].lv_heroUnit;

        }

        else {

            return lp_baseXPValue;

        }

        if ((libCore_gv_dataXPGranularBountyXPMathDisplayEnabled == true)) {

            TriggerDebugOutput(1, (StringExternal("Param/Value/lib_Core_46C0AE8D") + FixedToText(lp_baseXPValue, c_fixedPrecisionAny)), true);

        }



        lv_modifierCoefficient = (1.0 + ((libCore_gf_DataXPGetMoreGranularBountyXPModifier(lv_heroUnitOfAllyofDeadUnit, libGame_gv_players[lp_awardPlayer].lv_heroUnit) - 1.0) * 0.5));

        if ((lv_modifierCoefficient > 1)) {

            lv_finalXP = (lp_baseXPValue * lv_modifierCoefficient);

        }

        else {

            lv_finalXP = lp_baseXPValue;

        }

        if ((libCore_gv_dataXPGranularBountyXPMathDisplayEnabled == true)) {

            TriggerDebugOutput(1, (StringExternal("Param/Value/lib_Core_401C964A") + FixedToText(lv_finalXP, c_fixedPrecisionAny)), true);

        }



    }

    else {

        lv_finalXP = lp_baseXPValue;

    }

    lv_finalXP *= libCore_gv_data_XP_MinionXPModifier[libGame_gf_TeamNumberOfPlayer(lp_awardPlayer)];

    return lv_finalXP;

}



void libCore_gf_IncludeModInitialization (trigger t) {

    // Automatic Variable Declarations

    // Implementation

    TriggerAddEventGeneric(t, libCore_gv_eventID_IncludeModInit_C);

}



void libCore_gf_SendEventIncludeModInitialization () {

    // Automatic Variable Declarations

    // Implementation

    TriggerSendEvent(libCore_gv_eventID_IncludeModInit_C);

}



bool libCore_gf_MetagameIsHeroInRotationForPlayer (int lp_player, int lp_heroIndex) {

    // Variable Declarations

    int lv_itRotationReward;

    int lv_itRotationSlot;

    int lv_heroRotationSlotsAvailable;



    // Automatic Variable Declarations

    int auto1D5ED9EA_ae;

    const int auto1D5ED9EA_ai = 1;

    int autoC75C26EA_ae;

    const int autoC75C26EA_ai = 1;



    // Variable Initialization



    // Implementation

    lv_heroRotationSlotsAvailable = libCore_gv_metagame_DefaultRotationSlots_C;

    auto1D5ED9EA_ae = (CatalogFieldValueCount(c_gameCatalogConfig, "Config", "FreeToPlayRewardArray", c_playerAny) - 1);

    lv_itRotationReward = 0;

    for ( ; ( (auto1D5ED9EA_ai >= 0 && lv_itRotationReward <= auto1D5ED9EA_ae) || (auto1D5ED9EA_ai < 0 && lv_itRotationReward >= auto1D5ED9EA_ae) ) ; lv_itRotationReward += auto1D5ED9EA_ai ) {

        if ((PlayerHasReward(lp_player, (CatalogFieldValueGet(c_gameCatalogConfig, "Config", "FreeToPlayRewardArray[" + IntToString(lv_itRotationReward) + "]", lp_player))) == true)) {

            lv_heroRotationSlotsAvailable += 1;

        }



    }

    autoC75C26EA_ae = lv_heroRotationSlotsAvailable;

    lv_itRotationSlot = 1;

    for ( ; ( (autoC75C26EA_ai >= 0 && lv_itRotationSlot <= autoC75C26EA_ae) || (autoC75C26EA_ai < 0 && lv_itRotationSlot >= autoC75C26EA_ae) ) ; lv_itRotationSlot += autoC75C26EA_ai ) {

        if (((DataTableGetString(true, ("HeroIndex" + IntToString(lp_heroIndex)))) == (CatalogFieldValueGet(c_gameCatalogConfig, "Config", "FreeToPlayHeroArray[" + IntToString((lv_itRotationSlot - 1)) + "]", c_playerAny)))) {

            return true;

        }



    }

    return false;

}



bool libCore_gf_MetagameIsHeroInFreebieSet (int lp_heroIndex) {

    // Variable Declarations

    int lv_itFreeIdx;

    string lv_heroLink;



    // Automatic Variable Declarations

    int auto9EBF369B_ae;

    const int auto9EBF369B_ai = 1;



    // Variable Initialization



    // Implementation

    lv_heroLink = (DataTableGetString(true, ("HeroIndex" + IntToString(lp_heroIndex))));

    auto9EBF369B_ae = (CatalogFieldValueCount(c_gameCatalogConfig, "Config", "FreeToPlayNewUserHeroArray", c_playerAny) - 1);

    lv_itFreeIdx = 0;

    for ( ; ( (auto9EBF369B_ai >= 0 && lv_itFreeIdx <= auto9EBF369B_ae) || (auto9EBF369B_ai < 0 && lv_itFreeIdx >= auto9EBF369B_ae) ) ; lv_itFreeIdx += auto9EBF369B_ai ) {

        if ((lv_heroLink == (CatalogFieldValueGet(c_gameCatalogConfig, "Config", "FreeToPlayNewUserHeroArray[" + IntToString(lv_itFreeIdx) + "]", c_playerAny)))) {

            return true;

        }



    }

    return false;

}



bool libCore_gf_MetagameDoesPlayerHaveAccessToHero (int lp_player, int lp_heroIndex) {

    // Variable Declarations

    string lv_heroID;

    int lv_itRequiredReward;



    // Automatic Variable Declarations

    int auto7E5595FC_ae;

    const int auto7E5595FC_ai = 1;



    // Variable Initialization

    lv_heroID = "";



    // Implementation

    lv_heroID = DataTableGetString(true, ("HeroIndex_" + IntToString(lp_heroIndex)));

    if ((PlayerType(lp_player) == c_playerTypeComputer)) {

        return (CatalogFieldValueGetAsInt(c_gameCatalogHero, lv_heroID, "Flags[AllowAIRandomSelection]", c_playerAny) == 1);

    }



    if ((PlayerType(lp_player) == c_playerTypeUser) && (CatalogFieldValueGetAsInt(c_gameCatalogHero, lv_heroID, "Flags[AllowHumanRandomSelection]", c_playerAny) == 1)) {

        if (((libCore_gv_dEBUGGameIsOnline == false) || (libCore_gv_sYSGameMode == libCore_ge_GameModes_TryMe) || (libCore_gf_MetagameIsHeroInRotationForPlayer(lp_player, lp_heroIndex) == true) || ((GameIsPractice() == true) && (lv_heroID == CatalogFieldValueGet(c_gameCatalogConfig, "Config", "FreeToPlayPracticeHero", c_playerAny))) || ((libCore_gf_MetagameIsHeroInFreebieSet(lp_heroIndex) == true) && ((GameIsPractice() == true) || (GameIsCooperative() == true))))) {

            return true;

        }



        auto7E5595FC_ae = CatalogFieldValueCount(c_gameCatalogHero, lv_heroID, "RequiredRewardArray", c_playerAny);

        lv_itRequiredReward = 1;

        for ( ; ( (auto7E5595FC_ai >= 0 && lv_itRequiredReward <= auto7E5595FC_ae) || (auto7E5595FC_ai < 0 && lv_itRequiredReward >= auto7E5595FC_ae) ) ; lv_itRequiredReward += auto7E5595FC_ai ) {

            if ((PlayerHasReward(lp_player, (CatalogFieldValueGet(c_gameCatalogHero, lv_heroID, "RequiredRewardArray[" + IntToString((lv_itRequiredReward - 1)) + "]", c_playerAny))) == false)) {

                return false;

            }



        }

        return true;

    }



    return false;

}



bool libCore_gf_MetagameDoesPlayerHaveAccessToSkin (int lp_player, int lp_skinIndex) {

    // Variable Declarations

    string lv_skinID;

    int lv_itRequiredReward;



    // Automatic Variable Declarations

    int auto699BFD32_ae;

    const int auto699BFD32_ai = 1;



    // Variable Initialization

    lv_skinID = "";



    // Implementation

    if (((libCore_gv_dEBUGGameIsOnline == false) || (libCore_gv_sYSGameMode == libCore_ge_GameModes_TryMe) || (lp_skinIndex == 1))) {

        return true;

    }



    lv_skinID = (libCore_gf_DataSkinsGetSkinLinkFromSkinCatalogIndex(lp_skinIndex));

    auto699BFD32_ae = CatalogFieldValueCount(c_gameCatalogSkin, lv_skinID, "RequiredRewardArray", c_playerAny);

    lv_itRequiredReward = 1;

    for ( ; ( (auto699BFD32_ai >= 0 && lv_itRequiredReward <= auto699BFD32_ae) || (auto699BFD32_ai < 0 && lv_itRequiredReward >= auto699BFD32_ae) ) ; lv_itRequiredReward += auto699BFD32_ai ) {

        if ((PlayerHasReward(lp_player, (CatalogFieldValueGet(c_gameCatalogSkin, lv_skinID, "RequiredRewardArray[" + IntToString((lv_itRequiredReward - 1)) + "]", c_playerAny))) == false)) {

            return false;

        }



    }

    return true;

}



bool libCore_gf_MetagameDoesPlayerHaveAccessToMount (int lp_player, int lp_mountIndex) {

    // Variable Declarations

    int lv_itRequiredReward;

    string lv_mountLink;



    // Automatic Variable Declarations

    int auto7AC9FAB6_ae;

    const int auto7AC9FAB6_ai = 1;



    // Variable Initialization



    // Implementation

    lv_mountLink = libCore_gf_DataSkinsGetMountLinkFromMountIndex(lp_mountIndex);

    if (((lp_mountIndex == 1) || (libCore_gv_dEBUGGameIsOnline == false) || (libCore_gv_sYSGameMode == libCore_ge_GameModes_TryMe) || (CatalogFieldValueGetAsInt(c_gameCatalogMount, lv_mountLink, "Flags[FreePlay]", c_playerAny) == 1))) {

        return true;

    }



    auto7AC9FAB6_ae = CatalogFieldValueCount(c_gameCatalogMount, lv_mountLink, "RequiredRewardArray", c_playerAny);

    lv_itRequiredReward = 1;

    for ( ; ( (auto7AC9FAB6_ai >= 0 && lv_itRequiredReward <= auto7AC9FAB6_ae) || (auto7AC9FAB6_ai < 0 && lv_itRequiredReward >= auto7AC9FAB6_ae) ) ; lv_itRequiredReward += auto7AC9FAB6_ai ) {

        if ((PlayerHasReward(lp_player, (CatalogFieldValueGet(c_gameCatalogMount, lv_mountLink, "RequiredRewardArray[" + IntToString((lv_itRequiredReward - 1)) + "]", c_playerAny))) == false)) {

            return false;

        }



    }

    return true;

}



void libCore_gf_ExecuteEffectAtRandomPointsWithinCircle (string lp_effect, unit lp_casterUnit, int lp_numberOfExecutions, fixed lp_radius, point lp_centerPoint, bool lp_pointsMustBePathable) {

    // Variable Declarations

    const int lv_maxLoopCount = 50;

    int lv_i;

    region lv_region;

    point[51] lv_executionPoints;

    int lv_numberOfValidPoints;

    int lv_loopCount;

    bool lv_pointValid;

    point lv_testPoint;

    int lv_pointIndex;



    // Automatic Variable Declarations

    int autoDCCBECF5_ae;

    const int autoDCCBECF5_ai = 1;

    int autoB5F7F78A_ae;

    const int autoB5F7F78A_ai = 1;



    // Variable Initialization



    // Implementation

    lv_region = RegionCircle(lp_centerPoint, lp_radius);

    autoDCCBECF5_ae = lp_numberOfExecutions;

    lv_i = 1;

    for ( ; ( (autoDCCBECF5_ai >= 0 && lv_i <= autoDCCBECF5_ae) || (autoDCCBECF5_ai < 0 && lv_i >= autoDCCBECF5_ae) ) ; lv_i += autoDCCBECF5_ai ) {

        lv_loopCount = 0;

        lv_pointValid = false;

        while ((lv_pointValid == false)) {

            lv_loopCount += 1;

            if ((lv_loopCount == lv_maxLoopCount)) {

                break;

            }



            lv_testPoint = RegionRandomPoint(lv_region);

            if (((lp_pointsMustBePathable == false) || (PointPathingPassable(lv_testPoint) == true))) {

                lv_numberOfValidPoints += 1;

                lv_executionPoints[lv_numberOfValidPoints] = lv_testPoint;

                lv_pointValid = true;

            }



        }

    }

    autoB5F7F78A_ae = lp_numberOfExecutions;

    lv_i = 1;

    for ( ; ( (autoB5F7F78A_ai >= 0 && lv_i <= autoB5F7F78A_ae) || (autoB5F7F78A_ai < 0 && lv_i >= autoB5F7F78A_ae) ) ; lv_i += autoB5F7F78A_ai ) {

        lv_pointIndex = (ModI(lv_i, lv_numberOfValidPoints) + 1);

        UnitCreateEffectPoint(lp_casterUnit, lp_effect, lv_executionPoints[lv_pointIndex]);

    }

}



fixed libCore_gf_GetWeaponDamageForUnit (unit lp_unit) {

    // Variable Declarations

    int lv_itWeapon;



    // Automatic Variable Declarations

    int auto91D56C1A_ae;

    const int auto91D56C1A_ai = 1;



    // Variable Initialization



    // Implementation

    auto91D56C1A_ae = UnitWeaponCount(lp_unit);

    lv_itWeapon = 1;

    for ( ; ( (auto91D56C1A_ai >= 0 && lv_itWeapon <= auto91D56C1A_ae) || (auto91D56C1A_ai < 0 && lv_itWeapon >= auto91D56C1A_ae) ) ; lv_itWeapon += auto91D56C1A_ai ) {

        if ((UnitWeaponGet(lp_unit, lv_itWeapon) != null) && (UnitWeaponIsEnabled(lp_unit, lv_itWeapon) == true)) {

            return UnitWeaponDamage(lp_unit, lv_itWeapon, c_unitAttributeNone, false);

        }



    }

    return 0.0;

}



fixed libCore_gf_GetWeaponAttackSpeedForUnit (unit lp_unit) {

    // Variable Declarations

    int lv_itWeapon;



    // Automatic Variable Declarations

    int auto3CC89007_ae;

    const int auto3CC89007_ai = 1;



    // Variable Initialization



    // Implementation

    auto3CC89007_ae = UnitWeaponCount(lp_unit);

    lv_itWeapon = 1;

    for ( ; ( (auto3CC89007_ai >= 0 && lv_itWeapon <= auto3CC89007_ae) || (auto3CC89007_ai < 0 && lv_itWeapon >= auto3CC89007_ae) ) ; lv_itWeapon += auto3CC89007_ai ) {

        if ((UnitWeaponGet(lp_unit, lv_itWeapon) != null) && (UnitWeaponIsEnabled(lp_unit, lv_itWeapon) == true)) {

            return UnitWeaponSpeedMultiplier(lp_unit, lv_itWeapon);

        }



    }

    return 0.0;

}



int libCore_gf_CalculateGameLoopsFromReal (fixed lp_duration) {

    // Variable Declarations

    fixed lv_durationRealMod;

    int lv_durationLoops;



    // Automatic Variable Declarations

    // Variable Initialization



    // Implementation

    lv_durationRealMod = ModF(lp_duration, 0.0625);

    lv_durationLoops = FixedToInt((lp_duration / 0.0625));

    if ((lv_durationRealMod > 0.0)) {

        lv_durationLoops += 1;

    }



    return lv_durationLoops;

}



text libCore_gf_ConvertPointToText (point lp_point) {

    // Automatic Variable Declarations

    // Implementation

    TextExpressionSetToken("Param/Expression/lib_Core_80E5CA2E", "A", FixedToText(PointGetX(lp_point), 2));

    TextExpressionSetToken("Param/Expression/lib_Core_80E5CA2E", "B", FixedToText(PointGetY(lp_point), 2));

    return TextExpressionAssemble("Param/Expression/lib_Core_80E5CA2E");

}



string libCore_gf_GetTimeStamp (fixed lp_time) {

    // Variable Declarations

    fixed lv_elapsedTime;

    fixed lv_minutesElapsed;

    fixed lv_secondsElapsed;

    fixed lv_loopsElapsed;

    string lv_tempString;

    string lv_timeElapsedString;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_tempString = "";

    lv_timeElapsedString = "";



    // Implementation

    lv_elapsedTime = lp_time;

    lv_loopsElapsed = (ModF(lv_elapsedTime, 1.0) * 16.0);

    lv_elapsedTime -= (lv_loopsElapsed / 16.0);

    if ((lv_loopsElapsed < 10.0)) {

        lv_tempString = ("0" + FixedToString(lv_loopsElapsed, 0));

    }

    else {

        lv_tempString = FixedToString(lv_loopsElapsed, 0);

    }

    lv_timeElapsedString = lv_tempString;

    lv_secondsElapsed = ModF(lv_elapsedTime, 60.0);

    lv_elapsedTime -= lv_secondsElapsed;

    if ((lv_secondsElapsed < 10.0)) {

        lv_tempString = ("0" + FixedToString(lv_secondsElapsed, 0));

    }

    else {

        lv_tempString = FixedToString(lv_secondsElapsed, 0);

    }

    lv_timeElapsedString = (lv_tempString + ":" + lv_timeElapsedString);

    lv_minutesElapsed = (lv_elapsedTime / 60.0);

    if ((lv_minutesElapsed < 10.0)) {

        lv_tempString = ("0" + FixedToString(lv_minutesElapsed, 0));

    }

    else {

        lv_tempString = FixedToString(lv_minutesElapsed, 0);

    }

    lv_timeElapsedString = (lv_tempString + ":" + lv_timeElapsedString);

    return lv_timeElapsedString;

}



point libCore_gf_AdvancePointinDirection (point lp_point, point lp_dir, fixed lp_distance) {

    // Variable Declarations

    fixed lv_xVal;

    fixed lv_yVal;



    // Automatic Variable Declarations

    // Variable Initialization



    // Implementation

    lv_xVal = (PointGetX(lp_point) + (PointGetX(lp_dir) * lp_distance));

    lv_yVal = (PointGetY(lp_point) + (PointGetY(lp_dir) * lp_distance));

    return Point(lv_xVal, lv_yVal);

}



color libCore_gf_GetAllianceColorFromGameUIData (string lp_overrideColor, int lp_player) {

    // Variable Declarations

    color lv_neutralColor;

    string lv_fullColorString;

    int lv_commaPosition;

    string lv_rString;

    string lv_gString;

    string lv_bString;

    fixed lv_r;

    fixed lv_g;

    fixed lv_b;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_neutralColor = Color(0,0,0);

    lv_fullColorString = "";

    lv_rString = "";

    lv_gString = "";

    lv_bString = "";



    // Implementation

    lv_fullColorString = CatalogFieldValueGet(c_gameCatalogGameUI, "Dflt", "OverrideColors[" + lp_overrideColor + "].Value[0]", lp_player);

    lv_commaPosition = StringFind(lv_fullColorString, ",", c_stringCase);

    lv_rString = StringSub(lv_fullColorString, 1, (lv_commaPosition - 1));

    lv_fullColorString = StringSub(lv_fullColorString, (lv_commaPosition + 1), StringLength(lv_fullColorString));

    lv_commaPosition = StringFind(lv_fullColorString, ",", c_stringCase);

    lv_gString = StringSub(lv_fullColorString, 1, (lv_commaPosition - 1));

    lv_fullColorString = StringSub(lv_fullColorString, (lv_commaPosition + 1), StringLength(lv_fullColorString));

    lv_commaPosition = StringFind(lv_fullColorString, ",", c_stringCase);

    lv_bString = StringSub(lv_fullColorString, 1, (lv_commaPosition - 1));

    lv_r = (StringToFixed(lv_rString) * 100.0);

    lv_g = (StringToFixed(lv_gString) * 100.0);

    lv_b = (StringToFixed(lv_bString) * 100.0);

    return Color(lv_r, lv_g, lv_b);

}



int libCore_gf_GetNumberOfRanksOfAnAbilityAHeroHasLearned (unit lp_heroUnit, int lp_abilIndex) {

    // Variable Declarations

    int lv_i;

    string[4] lv_behaviorArray;



    // Automatic Variable Declarations

    const int auto60726184_ae = 3;

    const int auto60726184_ai = 1;



    // Variable Initialization



    // Implementation

    lv_i = 0;

    for ( ; ( (auto60726184_ai >= 0 && lv_i <= auto60726184_ae) || (auto60726184_ai < 0 && lv_i >= auto60726184_ae) ) ; lv_i += auto60726184_ai ) {

        lv_behaviorArray[lv_i] = "Ability" + IntToString(lv_i + 1);

    }

    return UnitBehaviorCount(lp_heroUnit, lv_behaviorArray[lp_abilIndex]);

}



string libCore_gf_GetModelLinkForUnitType (string lp_unitType) {

    // Variable Declarations

    string lv_unitTypeString;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_unitTypeString = "";



    // Implementation

    lv_unitTypeString = (lp_unitType);

    return (CatalogFieldValueGet(c_gameCatalogActor, (lv_unitTypeString), "Model", c_playerAny));

}



int libCore_gf_GetHeroIndexForUnitType (string lp_heroType) {

    // Variable Declarations

    int lv_itHero;

    int lv_itAlternateHero;

    int lv_heroIndex;

    int lv_heroCount;



    // Automatic Variable Declarations

    int auto9F1BE3ED_ae;

    const int auto9F1BE3ED_ai = 1;

    int auto2C6324CF_ae;

    const int auto2C6324CF_ai = 1;



    // Variable Initialization



    // Implementation

    lv_heroCount = libCore_gv_bALMaxPlayers;

    auto9F1BE3ED_ae = lv_heroCount;

    lv_itHero = 1;

    for ( ; ( (auto9F1BE3ED_ai >= 0 && lv_itHero <= auto9F1BE3ED_ae) || (auto9F1BE3ED_ai < 0 && lv_itHero >= auto9F1BE3ED_ae) ) ; lv_itHero += auto9F1BE3ED_ai ) {

        if ((lp_heroType == libGame_gv_players[lv_itHero].lv_heroData.lv_unitType)) {

            lv_heroIndex = lv_itHero;

            break;

        }

        else {

            if ((libGame_gv_players[lv_itHero].lv_heroData.lv_numberOfAlternateUnitTypes > 0)) {

                auto2C6324CF_ae = libGame_gv_players[lv_itHero].lv_heroData.lv_numberOfAlternateUnitTypes;

                lv_itAlternateHero = 1;

                for ( ; ( (auto2C6324CF_ai >= 0 && lv_itAlternateHero <= auto2C6324CF_ae) || (auto2C6324CF_ai < 0 && lv_itAlternateHero >= auto2C6324CF_ae) ) ; lv_itAlternateHero += auto2C6324CF_ai ) {

                    if ((lp_heroType == libGame_gv_players[lv_itHero].lv_heroData.lv_alternateUnitTypes[lv_itAlternateHero])) {

                        lv_heroIndex = lv_itHero;

                        break;

                    }



                }

            }



        }

    }

    return lv_heroIndex;

}



int libCore_gf_GetAbilityIndexForAbilityLink (int lp_heroIndex, string lp_abilLink) {

    // Variable Declarations

    int lv_i;



    // Automatic Variable Declarations

    const int auto23DF0436_ae = libCore_gv_dataHeroesMaxAbilitiesPerHero;

    const int auto23DF0436_ai = 1;



    // Variable Initialization



    // Implementation

    lv_i = 1;

    for ( ; ( (auto23DF0436_ai >= 0 && lv_i <= auto23DF0436_ae) || (auto23DF0436_ai < 0 && lv_i >= auto23DF0436_ae) ) ; lv_i += auto23DF0436_ai ) {

        if ((libGame_gv_players[lp_heroIndex].lv_heroData.lv_abilities[lv_i].lv_ability == lp_abilLink)) {

            return lv_i;

        }



    }

    return 0;

}



bool libCore_gf_TestLocationClosertoFactionSide (point lp_location, int lp_faction, fixed lp_modifier) {

    // Variable Declarations

    fixed lv_homeDist;

    fixed lv_enemyDist;



    // Automatic Variable Declarations

    // Variable Initialization



    // Implementation

    if (((lp_location == null) || (UnitIsValid(libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_core) == false) || (UnitIsValid(libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_core) == false))) {

        return false;

    }



    if ((lp_faction == libGame_ge_Faction_Order)) {

        lv_homeDist = DistanceBetweenPoints(UnitGetPosition(libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_core), lp_location);

        lv_enemyDist = DistanceBetweenPoints(UnitGetPosition(libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_core), lp_location);

    }

    else {

        lv_homeDist = DistanceBetweenPoints(UnitGetPosition(libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_core), lp_location);

        lv_enemyDist = DistanceBetweenPoints(UnitGetPosition(libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_core), lp_location);

    }

    if (((lv_homeDist * 2.0) <= (lp_modifier * (lv_homeDist + lv_enemyDist)))) {

        return true;

    }

    else {

        return false;

    }

}



fixed libCore_gf_StandalizedAngle (fixed lp_angle) {

    // Variable Declarations

    fixed lv_result;



    // Automatic Variable Declarations

    // Variable Initialization



    // Implementation

    lv_result = ModF(lp_angle, 360.0);

    if ((lv_result > 180.0)) {

        lv_result = (lv_result - 360.0);

    }

    else {

        if ((lv_result <= -180.0)) {

            lv_result = (lv_result + 360.0);

        }



    }

    return lv_result;

}



fixed libCore_gf_StandalizedAngleDifference (fixed lp_angle1, fixed lp_angle2) {

    // Variable Declarations

    fixed lv_diff;



    // Automatic Variable Declarations

    // Variable Initialization



    // Implementation

    lv_diff = ModF(AbsF((lp_angle1 - lp_angle2)), 360.0);

    if ((lv_diff > 180.0)) {

        lv_diff = AbsF((lv_diff - 360.0));

    }



    return lv_diff;

}



bool libCore_gf_IsAbilityOnCooldown (unit lp_unit, string lp_ability) {

    // Variable Declarations

    fixed lv_time;

    string lv_cooldownLink;

    string lv_chargeLink;

    fixed lv_chargeUsed;



    // Automatic Variable Declarations

    // Variable Initialization



    // Implementation

    lv_cooldownLink = CatalogFieldValueGet(c_gameCatalogAbil, lp_ability, "Cost[" + IntToString(0) + "].Cooldown.Link", c_playerAny);

    lv_time = UnitGetCooldown(lp_unit, lv_cooldownLink);

    if ((lv_time > 0.0)) {

        return true;

    }

    else {

        lv_chargeLink = CatalogFieldValueGet(c_gameCatalogAbil, lp_ability, "Cost[" + IntToString(0) + "].Charge.Link", c_playerAny);

        lv_chargeUsed = UnitGetChargeUsed(lp_unit, lv_chargeLink);

        if ((lv_chargeUsed > 0.0)) {

            lv_time = UnitGetChargeRegen(lp_unit, lv_chargeLink);

        }



    }

    return (lv_time > 0.0);

}



fixed libCore_gf_GetTotalHPForUnitIncludingAllShields (unit lp_unit) {

    // Automatic Variable Declarations

    // Implementation

    return (UnitGetPropertyFixed(lp_unit, c_unitPropLife, c_unitPropCurrent)+UnitGetPropertyFixed(lp_unit, c_unitPropShields, c_unitPropCurrent)+UnitBehaviorDamageModifyRemaining(lp_unit, null));

}



fixed libCore_gf_GetTotalXPForLevel (int lp_level) {

    // Automatic Variable Declarations

    // Implementation

    if (((lp_level > libCore_gv_bALMaxLevel) || (lp_level < 1))) {

        return 0.0;

    }

    else {

        return libCore_gv_dataXPLevelXPValues[lp_level];

    }

}



int libCore_gf_GetPlayerIDfromTeamSlot (int lp_slot, int lp_team) {

    // Variable Declarations

    int lv_itPlayer;



    // Automatic Variable Declarations

    int auto0AFF2404_ae;



    // Variable Initialization



    // Implementation

    auto0AFF2404_ae = libCore_gv_bALMaxPlayers;

    lv_itPlayer = 1;

    for ( ; lv_itPlayer <= auto0AFF2404_ae ; lv_itPlayer += 1 ) {

        if ((libGame_gv_players[lv_itPlayer].lv_teamPlayerSlot == lp_slot) && (libGame_gf_TeamNumberOfPlayer(lv_itPlayer) == lp_team)) {

            return lv_itPlayer;

        }



    }

    return 0;

}



void libCore_gf_SendActorMessageToDoodadsInRegion (string lp_message, region lp_target, string lp_doodadType) {

    // Variable Declarations

    actor lv_actorRegion;

    string lv_termsString;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_termsString = "";



    // Implementation

    ActorRegionCreate(null, "TriggerRegion", lp_target);

    lv_actorRegion = libNtve_gf_ActorLastCreated();

    if ((lp_doodadType != null)) {

        lv_termsString = ("ScopeContains " + lp_doodadType);

    }



    ActorRegionSend(lv_actorRegion, c_actorIntersectAgainstRadiusContact, lp_message, "Doodad", lv_termsString);

    ActorScopeKill(ActorScopeFromActor(lv_actorRegion));

}



void libCore_gf_ClearAllNonpermanentBehaviorsonUnit (unit lp_targetUnit) {

    // Variable Declarations

    int lv_itBehavior;

    string lv_behavior;

    string[51] lv_behaviorsToBeRemoved;

    int lv_behaviorsToBeRemovedCount;



    // Automatic Variable Declarations

    const int auto6DC7FEE5_ae = 1;

    const int auto6DC7FEE5_ai = -1;

    int auto8A5EF4E4_ae;

    const int auto8A5EF4E4_ai = 1;



    // Variable Initialization



    // Implementation

    lv_itBehavior = UnitBehaviorCountAll(lp_targetUnit);

    for ( ; ( (auto6DC7FEE5_ai >= 0 && lv_itBehavior <= auto6DC7FEE5_ae) || (auto6DC7FEE5_ai < 0 && lv_itBehavior >= auto6DC7FEE5_ae) ) ; lv_itBehavior += auto6DC7FEE5_ai ) {

        lv_behavior = UnitBehaviorGet(lp_targetUnit, lv_itBehavior);

        if ((CatalogFieldValueGetAsInt(c_gameCatalogBehavior, lv_behavior, "BehaviorFlags[" + IntToString(0) + "]", c_playerAny) != 1)) {

            lv_behaviorsToBeRemovedCount += 1;

            lv_behaviorsToBeRemoved[lv_behaviorsToBeRemovedCount] = lv_behavior;

        }



    }

    auto8A5EF4E4_ae = lv_behaviorsToBeRemovedCount;

    lv_itBehavior = 1;

    for ( ; ( (auto8A5EF4E4_ai >= 0 && lv_itBehavior <= auto8A5EF4E4_ae) || (auto8A5EF4E4_ai < 0 && lv_itBehavior >= auto8A5EF4E4_ae) ) ; lv_itBehavior += auto8A5EF4E4_ai ) {

        UnitBehaviorRemove(lp_targetUnit, lv_behaviorsToBeRemoved[lv_itBehavior], c_unitBehaviorCountAll);

    }

}



bool libCore_gf_LoadBankValueIfExistsAsBoolean (bool lp_variable, bank lp_bank, string lp_key, string lp_section) {

    // Automatic Variable Declarations

    // Implementation

    if ((BankKeyExists(lp_bank, lp_section, lp_key) == true)) {

        return BankValueGetAsFlag(lp_bank, lp_section, lp_key);

    }

    else {

        return lp_variable;

    }

}



int libCore_gf_LoadBankValueIfExistsAsInteger (int lp_variable, bank lp_bank, string lp_key, string lp_section) {

    // Automatic Variable Declarations

    // Implementation

    if ((BankKeyExists(lp_bank, lp_section, lp_key) == true)) {

        return BankValueGetAsInt(lp_bank, lp_section, lp_key);

    }

    else {

        return lp_variable;

    }

}



fixed libCore_gf_LoadBankValueIfExistsAsReal (fixed lp_variable, bank lp_bank, string lp_key, string lp_section) {

    // Automatic Variable Declarations

    // Implementation

    if ((BankKeyExists(lp_bank, lp_section, lp_key) == true)) {

        return BankValueGetAsFixed(lp_bank, lp_section, lp_key);

    }

    else {

        return lp_variable;

    }

}



string libCore_gf_LoadBankValueIfExistsAsString (string lp_variable, bank lp_bank, string lp_key, string lp_section) {

    // Automatic Variable Declarations

    // Implementation

    if ((BankKeyExists(lp_bank, lp_section, lp_key) == true)) {

        return BankValueGetAsString(lp_bank, lp_section, lp_key);

    }

    else {

        return lp_variable;

    }

}



void libCore_gf_CreateMinimapPingStorm (playergroup lp_players, string lp_pingData, point lp_position, color lp_color, fixed lp_duration) {

    // Automatic Variable Declarations

    // Implementation

    PingCreateFromData(lp_players, lp_pingData, lp_position);

    if ((lp_color != ColorWithAlpha(0,0,0,0))) {

        PingSetColor(PingLastCreated(), lp_color);

    }



    if ((lp_duration != -1)) {

        PingSetDuration(PingLastCreated(), lp_duration);

    }



}



void libCore_gf_CreateMinimapPingStormWithPlayerId (playergroup lp_players, string lp_pingData, point lp_position, color lp_color, fixed lp_duration, int lp_playerId) {

    // Automatic Variable Declarations

    // Implementation

    PingCreateFromDataWithPlayerId(lp_players, lp_pingData, lp_position, lp_playerId);

    if ((lp_color != ColorWithAlpha(0,0,0,0))) {

        PingSetColor(PingLastCreated(), lp_color);

    }



    if ((lp_duration != -1)) {

        PingSetDuration(PingLastCreated(), lp_duration);

    }



}



string libCore_gf_ZS_ReticleModelOfStyle (int lp_type, int lp_size) {

    // Variable Declarations

    string lv_model;



    // Automatic Variable Declarations

    int autoA0502110_val;

    int autoF013B30C_val;

    int auto0C52B5A0_val;

    int auto21E76831_val;



    // Variable Initialization



    // Implementation

    autoA0502110_val = lp_size;

    if (autoA0502110_val == libCore_ge_ReticleSize_Large) {

        autoF013B30C_val = lp_type;

        if (autoF013B30C_val == libCore_ge_ReticleType_BonusObjective) {

            lv_model = "Storm_UI_Briefing_UnitSelect";

        }

        else if (autoF013B30C_val == libCore_ge_ReticleType_Enemy) {

            lv_model = "Storm_UI_Briefing_UnitSelect";

        }

        else if (autoF013B30C_val == libCore_ge_ReticleType_MainObjective) {

            lv_model = "Storm_UI_Briefing_UnitSelect";

        }

        else {

        }

    }

    else if (autoA0502110_val == libCore_ge_ReticleSize_Medium) {

        auto0C52B5A0_val = lp_type;

        if (auto0C52B5A0_val == libCore_ge_ReticleType_BonusObjective) {

            lv_model = "Storm_UI_Briefing_UnitSelect";

        }

        else if (auto0C52B5A0_val == libCore_ge_ReticleType_Enemy) {

            lv_model = "Storm_UI_Briefing_UnitSelect";

        }

        else if (auto0C52B5A0_val == libCore_ge_ReticleType_MainObjective) {

            lv_model = "Storm_UI_Briefing_UnitSelect";

        }

        else {

        }

    }

    else if (autoA0502110_val == libCore_ge_ReticleSize_Small) {

        auto21E76831_val = lp_type;

        if (auto21E76831_val == libCore_ge_ReticleType_BonusObjective) {

            lv_model = "Storm_UI_Briefing_UnitSelect";

        }

        else if (auto21E76831_val == libCore_ge_ReticleType_Enemy) {

            lv_model = "Storm_UI_Briefing_UnitSelect";

        }

        else if (auto21E76831_val == libCore_ge_ReticleType_MainObjective) {

            lv_model = "Storm_UI_Briefing_UnitSelect";

        }

        else {

        }

    }

    else {

    }

    return lv_model;

}



string libCore_gf_ZS_ReticleTextFontOfStyle (int lp_type) {

    // Variable Declarations

    string lv_fontStyle;



    // Automatic Variable Declarations

    int auto5627CFC0_val;



    // Variable Initialization

    lv_fontStyle = "SwarmReticleZergMainObjective";



    // Implementation

    auto5627CFC0_val = lp_type;

    if (auto5627CFC0_val == libCore_ge_ReticleType_BonusObjective) {

        lv_fontStyle = "ReticleBonusObjective";

    }

    else if (auto5627CFC0_val == libCore_ge_ReticleType_Enemy) {

        lv_fontStyle = "ReticleEnemy";

    }

    else if (auto5627CFC0_val == libCore_ge_ReticleType_MainObjective) {

        lv_fontStyle = "ReticleMainObjective";

    }

    else {

    }

    return lv_fontStyle;

}



void libCore_gf__CreateReticleEffect (int lp_type, int lp_size, point lp_location) {

    // Variable Declarations

    string lv_model;



    // Automatic Variable Declarations

    int auto6033BF13_val;

    int auto652E26F1_val;



    // Variable Initialization



    // Implementation

    lv_model = libCore_gf_ZS_ReticleModelOfStyle(lp_type, lp_size);

    if ((lv_model == null)) {

        return ;

    }



    libNtve_gf_CreateModelAtPoint(lv_model, lp_location);

    auto6033BF13_val = lp_size;

    if (auto6033BF13_val == libCore_ge_ReticleSize_Large) {

        ActorSend(libNtve_gf_ActorLastCreated(), "SetScale 1.500000");

    }

    else if (auto6033BF13_val == libCore_ge_ReticleSize_Medium) {

        ActorSend(libNtve_gf_ActorLastCreated(), "SetScale 1.200000");

    }

    else if (auto6033BF13_val == libCore_ge_ReticleSize_Small) {

        ActorSend(libNtve_gf_ActorLastCreated(), "SetScale 0.900000");

    }

    else {

    }

    auto652E26F1_val = lp_type;

    if (auto652E26F1_val == libCore_ge_ReticleType_MainObjective) {

        ActorSend(libNtve_gf_ActorLastCreated(), "SetTintColor 0,255,0");

    }

    else if (auto652E26F1_val == libCore_ge_ReticleType_BonusObjective) {

        ActorSend(libNtve_gf_ActorLastCreated(), "SetTintColor 255,255,0");

    }

    else if (auto652E26F1_val == libCore_ge_ReticleType_Enemy) {

        ActorSend(libNtve_gf_ActorLastCreated(), "SetTintColor 255,0,0");

    }

    else {

    }

}



void libCore_gf__AttachReticleEffect (int lp_type, int lp_size, unit lp_target, string lp_attachPoint) {

    // Variable Declarations

    string lv_model;



    // Automatic Variable Declarations

    int auto09B9443F_val;

    int auto66D2BF36_val;



    // Variable Initialization



    // Implementation

    lv_model = libCore_gf_ZS_ReticleModelOfStyle(lp_type, lp_size);

    if ((lv_model == null)) {

        return ;

    }



    libNtve_gf_AttachModelToUnit(lp_target, lv_model, lp_attachPoint);

    auto09B9443F_val = lp_size;

    if (auto09B9443F_val == libCore_ge_ReticleSize_Large) {

        ActorSend(libNtve_gf_ActorLastCreated(), "SetScale 1.500000");

    }

    else if (auto09B9443F_val == libCore_ge_ReticleSize_Medium) {

        ActorSend(libNtve_gf_ActorLastCreated(), "SetScale 1.200000");

    }

    else if (auto09B9443F_val == libCore_ge_ReticleSize_Small) {

        ActorSend(libNtve_gf_ActorLastCreated(), "SetScale");

    }

    else {

    }

    auto66D2BF36_val = lp_type;

    if (auto66D2BF36_val == libCore_ge_ReticleType_MainObjective) {

        ActorSend(libNtve_gf_ActorLastCreated(), "SetTintColor 0,255,0");

    }

    else if (auto66D2BF36_val == libCore_ge_ReticleType_BonusObjective) {

        ActorSend(libNtve_gf_ActorLastCreated(), "SetTintColor 255,255,0");

    }

    else if (auto66D2BF36_val == libCore_ge_ReticleType_Enemy) {

        ActorSend(libNtve_gf_ActorLastCreated(), "SetTintColor 255,0,0");

    }

    else {

    }

}



void libCore_gf_CreateReticleEffectAndTextTagAtPoint (int lp_type, int lp_size, text lp_text, point lp_location) {

    // Variable Declarations

    string lv_model;

    string lv_fontStyle;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_fontStyle = "SwarmReticleZergMainObjective";



    // Implementation

    libCore_gf__CreateReticleEffect(lp_type, lp_size, lp_location);

    if (((lp_text != null) == false)) {

        return ;

    }



    lv_fontStyle = libCore_gf_ZS_ReticleTextFontOfStyle(lp_type);

    TextExpressionSetToken("Param/Expression/lib_Core_05F16B54", "Style", StringToText((lv_fontStyle)));

    TextExpressionSetToken("Param/Expression/lib_Core_05F16B54", "A", lp_text);

    TextTagCreate(TextExpressionAssemble("Param/Expression/lib_Core_05F16B54"), 24, lp_location, 0.0, true, true, PlayerGroupSingle(1));

    TextTagSetFogVisibility(TextTagLastCreated(), c_visTypeFog);

}



void libCore_gf_AttachTextTagOnUnit (int lp_type, text lp_text, unit lp_target, string lp_attachPoint) {

    // Variable Declarations

    string lv_model;

    string lv_fontStyle;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_fontStyle = "SwarmReticleZergMainObjective";



    // Implementation

    if (((lp_text != null) == false)) {

        return ;

    }



    lv_fontStyle = libCore_gf_ZS_ReticleTextFontOfStyle(lp_type);

    TextExpressionSetToken("Param/Expression/lib_Core_F9276DCB", "Style", StringToText((lv_fontStyle)));

    TextExpressionSetToken("Param/Expression/lib_Core_F9276DCB", "A", lp_text);

    TextTagCreate(TextExpressionAssemble("Param/Expression/lib_Core_F9276DCB"), 24, UnitGetPosition(lp_target), 0.0, true, true, PlayerGroupSingle(1));

    TextTagAttachToUnit(TextTagLastCreated(), lp_target, 0.0);

    TextTagSetFogVisibility(TextTagLastCreated(), c_visTypeFog);

}



void libCore_gf_AttachReticleEffectAndTextTagOnUnit (int lp_type, int lp_size, text lp_text, unit lp_target, string lp_attachPoint) {

    // Variable Declarations

    string lv_model;

    string lv_fontStyle;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_fontStyle = "SwarmReticleZergMainObjective";



    // Implementation

    libCore_gf__AttachReticleEffect(lp_type, lp_size, lp_target, lp_attachPoint);

    if (((lp_text != null) == false)) {

        return ;

    }



    libCore_gf_AttachTextTagOnUnit(lp_type, lp_text, lp_target, lp_attachPoint);

}



string libCore_gf__UnitDataName (int lp_type, unit lp_unit, int lp_index) {

    // Variable Declarations

    string lv_name;



    // Automatic Variable Declarations

    int auto240754E1_val;



    // Variable Initialization

    lv_name = "";



    // Implementation

    auto240754E1_val = lp_type;

    if (auto240754E1_val == libCore_ge__UnitDataType_Actor) {

        lv_name = "UDACTOR_";

    }

    else if (auto240754E1_val == libCore_ge__UnitDataType_Integer) {

        lv_name = "UDINTEGER_";

    }

    else if (auto240754E1_val == libCore_ge__UnitDataType_Ping) {

        lv_name = "UDPING_";

    }

    else if (auto240754E1_val == libCore_ge__UnitDataType_Point) {

        lv_name = "UDPOINT_";

    }

    else if (auto240754E1_val == libCore_ge__UnitDataType_Region) {

        lv_name = "UDREGION_";

    }

    else if (auto240754E1_val == libCore_ge__UnitDataType_TextTag) {

        lv_name = "UDTEXTTAG_";

    }

    else if (auto240754E1_val == libCore_ge__UnitDataType_Unit) {

        lv_name = "UDUNIT_";

    }

    else if (auto240754E1_val == libCore_ge__UnitDataType_UnitGroup) {

        lv_name = "UDUNITGROUP_";

    }

    else {

    }

    lv_name = (lv_name + IntToString(UnitGetTag(lp_unit)) + "_" + IntToString(lp_index));

    return lv_name;

}



void libCore_gf_StoreActorForUnit (unit lp_unit, int lp_index, actor lp_actor) {

    // Automatic Variable Declarations

    // Implementation

    DataTableSetActor(true, libCore_gf__UnitDataName(libCore_ge__UnitDataType_Actor, lp_unit, lp_index), lp_actor);

}



actor libCore_gf_ActorStoredForUnit (unit lp_unit, int lp_index) {

    // Automatic Variable Declarations

    // Implementation

    return DataTableGetActor(true, libCore_gf__UnitDataName(libCore_ge__UnitDataType_Actor, lp_unit, lp_index));

}



void libCore_gf_StoreTextTagForUnit (unit lp_unit, int lp_index, int lp_textTag) {

    // Automatic Variable Declarations

    // Implementation

    libNtve_gf_SaveDataTableValueTextTag(true, libCore_gf__UnitDataName(libCore_ge__UnitDataType_TextTag, lp_unit, lp_index), lp_textTag);

}



int libCore_gf_TextTagStoredForUnit (unit lp_unit, int lp_index) {

    // Automatic Variable Declarations

    // Implementation

    return libNtve_gf_ValueFromDataTableTextTag(true, libCore_gf__UnitDataName(libCore_ge__UnitDataType_TextTag, lp_unit, lp_index));

}



void libCore_gf_StorePointForUnit (unit lp_unit, int lp_index, point lp_point) {

    // Automatic Variable Declarations

    // Implementation

    DataTableSetPoint(true, libCore_gf__UnitDataName(libCore_ge__UnitDataType_Point, lp_unit, lp_index), lp_point);

}



point libCore_gf_PointStoredForUnit (unit lp_unit, int lp_index) {

    // Automatic Variable Declarations

    // Implementation

    return DataTableGetPoint(true, libCore_gf__UnitDataName(libCore_ge__UnitDataType_Point, lp_unit, lp_index));

}



void libCore_gf_StoreRegionForUnit (unit lp_unit, int lp_index, region lp_region) {

    // Automatic Variable Declarations

    // Implementation

    DataTableSetRegion(true, libCore_gf__UnitDataName(libCore_ge__UnitDataType_Point, lp_unit, lp_index), lp_region);

}



region libCore_gf_RegionStoredForUnit (unit lp_unit, int lp_index) {

    // Automatic Variable Declarations

    // Implementation

    return DataTableGetRegion(true, libCore_gf__UnitDataName(libCore_ge__UnitDataType_Point, lp_unit, lp_index));

}



void libCore_gf_StorePingForUnit (unit lp_unit, int lp_index, int lp_ping) {

    // Automatic Variable Declarations

    // Implementation

    DataTableSetPing(true, libCore_gf__UnitDataName(libCore_ge__UnitDataType_Ping, lp_unit, lp_index), lp_ping);

}



int libCore_gf_PingStoredForUnit (unit lp_unit, int lp_index) {

    // Automatic Variable Declarations

    // Implementation

    return DataTableGetPing(true, libCore_gf__UnitDataName(libCore_ge__UnitDataType_Ping, lp_unit, lp_index));

}



void libCore_gf_StoreIntegerForUnit (unit lp_unit, int lp_index, int lp_value) {

    // Automatic Variable Declarations

    // Implementation

    DataTableSetInt(true, libCore_gf__UnitDataName(libCore_ge__UnitDataType_Integer, lp_unit, lp_index), lp_value);

}



int libCore_gf_IntegerStoredForUnit (unit lp_unit, int lp_index) {

    // Automatic Variable Declarations

    // Implementation

    return DataTableGetInt(true, libCore_gf__UnitDataName(libCore_ge__UnitDataType_Integer, lp_unit, lp_index));

}



void libCore_gf_StoreUnitForUnit (unit lp_unit, int lp_index, unit lp_value) {

    // Automatic Variable Declarations

    // Implementation

    DataTableSetUnit(true, libCore_gf__UnitDataName(libCore_ge__UnitDataType_Unit, lp_unit, lp_index), lp_value);

}



unit libCore_gf_UnitStoredForUnit (unit lp_unit, int lp_index) {

    // Automatic Variable Declarations

    // Implementation

    return DataTableGetUnit(true, libCore_gf__UnitDataName(libCore_ge__UnitDataType_Unit, lp_unit, lp_index));

}



void libCore_gf_StoreUnitGroupForUnit (unit lp_unit, int lp_index, unitgroup lp_value) {

    // Automatic Variable Declarations

    // Implementation

    DataTableSetUnitGroup(true, libCore_gf__UnitDataName(libCore_ge__UnitDataType_UnitGroup, lp_unit, lp_index), lp_value);

}



unitgroup libCore_gf_UnitGroupStoredForUnit (unit lp_unit, int lp_index) {

    // Automatic Variable Declarations

    // Implementation

    return DataTableGetUnitGroup(true, libCore_gf__UnitDataName(libCore_ge__UnitDataType_UnitGroup, lp_unit, lp_index));

}



void libCore_gf_PlayTransmissionCueSound (playergroup lp_playerGroup) {

    // Automatic Variable Declarations

    // Implementation

    SoundPlayForPlayer(SoundLink("Dialogue_TransmissionStart", 0), c_maxPlayers, lp_playerGroup, 100.0, 0.0);

    Wait(0.25, c_timeReal);

}



void libCore_gf_SetAllSoundChannelVolumesStandardTiming (int lp_mode, playergroup lp_players) {

    // Automatic Variable Declarations

    // Implementation

    if ((lp_mode == libNtve_ge_VolumeChannelMode_Game)) {

        libNtve_gf_SetAllSoundChannelVolumes(lp_mode, lp_players, 2.5);

        SoundChannelSetVolume(lp_players, c_soundCategoryVoice, 100.0, 0.5);

        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryUI, 100.0, 0.5);

        SoundChannelSetVolume(lp_players, c_soundCategorySpellOneshotImpact, 100.0, 0.5);

    }

    else {

        libNtve_gf_SetAllSoundChannelVolumes(lp_mode, lp_players, 1.0);

        SoundChannelSetVolume(lp_players, c_soundCategoryVoice, 0.0, 0.25);

        SoundChannelSetVolume(lp_players, c_soundCategorySpellOneshotImpact, 0.0, 0.25);

    }

}



bool libCore_gf_PlayerGroupOverlap (playergroup lp_group1, playergroup lp_group2) {

    // Variable Declarations

    int lv_itPlayer;



    // Automatic Variable Declarations

    playergroup auto2201786C_g;



    // Variable Initialization



    // Implementation

    auto2201786C_g = lp_group1;

    lv_itPlayer = -1;

    while (true) {

        	lv_itPlayer = PlayerGroupNextPlayer(auto2201786C_g, lv_itPlayer);

        	if (lv_itPlayer<0) { break; }

        	if ((PlayerGroupHasPlayer(lp_group2, lv_itPlayer) == true)) {

            return true;

        }



    }

    return false;

}



int libCore_gf_TransmissionOwningPlayerFromPlayerGroup (playergroup lp_toPlayers) {

    // Automatic Variable Declarations

    // Implementation

    if ((libCore_gf_PlayerGroupOverlap(libGame_gf_PlayersOnTeamHeroes(2, false), lp_toPlayers) == true) && (libCore_gf_PlayerGroupOverlap(libGame_gf_PlayersOnTeamHeroes(2, false), lp_toPlayers) == true)) {

        return (c_maxPlayers);

    }



    if ((libCore_gf_PlayerGroupOverlap(libGame_gf_PlayersOnTeamHeroes(1, false), lp_toPlayers) == true)) {

        return libCore_gv_cOMPUTER_TeamOrder;

    }



    if ((libCore_gf_PlayerGroupOverlap(libGame_gf_PlayersOnTeamHeroes(2, false), lp_toPlayers) == true)) {

        return libCore_gv_cOMPUTER_TeamOrder;

    }



    if ((PlayerGroupHasPlayer(lp_toPlayers, libCore_gv_oBSERVER_ObserverUIPlayer) == true)) {

        return libCore_gv_oBSERVER_ObserverUIPlayer;

    }



    return (c_maxPlayers);

}



void libCore_gf_SendTransmissionCampaign (unit lp_unit, string lp_conversationLine, int lp_durationType, fixed lp_duration, bool lp_waitUntilDone, int lp_keepPortraitVisible, int lp_cueSoundOption) {

    // Variable Declarations

    soundlink lv_sound;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_sound = SoundLink("EditorDefaultSound", -1);



    // Implementation

    lv_sound = SoundLink(ConversationDataGetSound(lp_conversationLine, true), c_soundIndexAny);

    if ((lv_sound == null)) {

        return ;

    }



    libCore_gf_ZS_SendTransmissionCampaignInternal(false, lp_unit, null, lv_sound, null, null, lp_durationType, lp_duration, lp_waitUntilDone, lp_keepPortraitVisible, lp_cueSoundOption, CatalogFieldValueGet(c_gameCatalogSound, ConversationDataGetSound(lp_conversationLine, true), "AssetArray[" + IntToString(0) + "].PortraitActor", c_playerAny));

}



void libCore_gf_SendTransmissionCampaignPlaceHolder (unit lp_unit, string lp_model, text lp_speaker, text lp_message, fixed lp_duration, bool lp_waitUntilDone, int lp_keepPortraitVisible2, int lp_cueSoundOption2) {

    // Variable Declarations

    soundlink lv_sound;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_sound = SoundLink("EditorDefaultSound", -1);



    // Implementation

    lv_sound = SoundLink("PlaceholderSoundFile", c_soundIndexAny);

    TextExpressionSetToken("Param/Expression/lib_Core_F4BD8250", "A", lp_message);

    libCore_gf_ZS_SendTransmissionCampaignInternal(true, lp_unit, lp_model, lv_sound, lp_speaker, TextExpressionAssemble("Param/Expression/lib_Core_F4BD8250"), c_transmissionDurationSet, lp_duration, lp_waitUntilDone, lp_keepPortraitVisible2, lp_cueSoundOption2, "");

}



void libCore_gf_SendTransmissionToPlayerStorm (unit lp_unit, string lp_conversationLine, int lp_durationType, fixed lp_duration, bool lp_waitUntilDone, int lp_keepPortraitVisible, int lp_cueSoundOption, int lp_player) {

    // Variable Declarations

    soundlink lv_sound;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_sound = SoundLink("EditorDefaultSound", -1);



    // Implementation

    lv_sound = SoundLink(ConversationDataGetSound(lp_conversationLine, true), c_soundIndexAny);

    if ((lv_sound == null)) {

        return ;

    }



    libCore_gf_ZS_SendTransmissionCampaignInternal2(false, lp_unit, null, lv_sound, null, null, lp_durationType, lp_duration, lp_waitUntilDone, lp_keepPortraitVisible, lp_cueSoundOption, CatalogFieldValueGet(c_gameCatalogSound, ConversationDataGetSound(lp_conversationLine, true), "AssetArray[" + IntToString(0) + "].PortraitActor", c_playerAny), lp_player);

}



void libCore_gf_TurnTransmissionOptionsOnOffCampaign (int lp_option, bool lp_onOff) {

    // Automatic Variable Declarations

    int auto2C2547CF_val;



    // Implementation

    auto2C2547CF_val = lp_option;

    if (auto2C2547CF_val == libCore_ge_TransmissionOptions_ChatBubble) {

        libCore_gv_zS_SendTransmissionCampaignChatBubbleOn = lp_onOff;

    }

    else {

    }

}



void libCore_gf_ZS_SendTransmissionCampaignInternal (bool lp_isPlaceHolder, unit lp_unit, string lp_model, soundlink lp_sound, text lp_speaker, text lp_message, int lp_durationType, fixed lp_duration, bool lp_waitUntilDone, int lp_keepPortraitVisible, int lp_cueSoundOption, string lp_portraitActor) {

    // Variable Declarations

    int lv_portrait;

    transmissionsource lv_source;

    int lv_localIndex;

    unit lv_oldSpeaker;

    trigger lv_oldTrigger;

    actor lv_talkBubble;

    actor lv_talkRing;

    int lv_ping;

    bool lv_flashOption;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_portrait = c_invalidPortraitId;

    lv_source = TransmissionSource();

    lv_ping = c_invalidPingId;

    lv_flashOption = true;



    // Implementation

    if ((lp_sound == null)) {

        return ;

    }



    libCore_gv_zS_SendTransmissionCampaignIndex += 1;

    lv_localIndex = libCore_gv_zS_SendTransmissionCampaignIndex;

    lv_oldSpeaker = libCore_gv_zS_SendTransmissionCampaignSpeaker;

    libCore_gv_zS_SendTransmissionCampaignSpeaker = lp_unit;

    lv_oldTrigger = libCore_gv_zS_SendTransmissionCampaignTrigger;

    libCore_gv_zS_SendTransmissionCampaignTrigger = TriggerGetCurrent();

    if ((lp_keepPortraitVisible != libCore_ge_TransmissionPortraitOptioins_DontShowPortrait) && ((lp_model != null) || ((lp_model == null) && (SoundPortraitModel(lp_sound) != null)) || ((lp_isPlaceHolder == true) && (lp_unit != null)))) {

        if ((libNtve_gf_PlayerInCinematicMode(1) == false) && (libNtve_gf_PlayerInStoryMode(1) == false)) {

            lv_portrait = PortraitGetGame();

        }

        else {

            lv_portrait = c_invalidPortraitId;

        }

    }

    else {

        lv_portrait = c_invalidPortraitId;

    }

    if ((lv_portrait != c_invalidPortraitId)) {

        if ((lp_unit != null)) {

            if ((PlayerGroupHasPlayer(libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamOrderIndex_C, true), UnitGetOwner(lp_unit)) == true)) {

                PortraitSetTeamColor(lv_portrait, libNtve_gf_ConvertPlayerColorToColor(2));

            }

            else if ((PlayerGroupHasPlayer(libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamChaosIndex_C, true), UnitGetOwner(lp_unit)) == true)) {

                PortraitSetTeamColor(lv_portrait, libNtve_gf_ConvertPlayerColorToColor(1));

            }

            else if (true) {

                PortraitSetTeamColor(lv_portrait, libNtve_gf_ConvertPlayerColorToColor(2));

            }

        }

        else {

            PortraitSetTeamColor(lv_portrait, libNtve_gf_ConvertPlayerColorToColor(2));

        }

    }



    libCore_gv_zS_SendTransmissionCampaignPortrait = lv_portrait;

    if ((libCore_gv_zS_SendTransmissionCampaignPortrait != c_invalidPortraitId)) {

        PortraitSetVisible(libCore_gv_zS_SendTransmissionCampaignPortrait, PlayerGroupAll(), true, false);

    }



    libCore_gv_zS_SendTransmissionCampaignPlayingTick = 3;

    if ((lp_unit == null)) {

        if ((lv_portrait == c_invalidPortraitId)) {

            lv_source = TransmissionSource();

        }

        else {

            if ((lp_model == null)) {

                lv_source = TransmissionSourceFromModel(null);

            }

            else {

                lv_source = TransmissionSourceFromModel(lp_model);

            }

        }

    }

    else {

        if ((libNtve_gf_PlayerInCinematicMode(1) == true)) {

            lv_flashOption = false;

        }

        else {

            lv_flashOption = true;

        }

        if ((lp_isPlaceHolder == false)) {

            lv_source = TransmissionSourceFromUnit(lp_unit, lv_flashOption, false, "");

        }

        else {

            if ((lp_model == null)) {

                if ((UnitGetOwner(EventUnit()) == 1)) {

                    lv_source = TransmissionSourceFromUnit(lp_unit, lv_flashOption, false, "");

                }



            }

            else {

                lv_source = TransmissionSourceFromModel(lp_model);

            }

            lv_source = TransmissionSourceFromModel(lp_model);

        }

    }

    if ((lp_unit != null) && (UnitIsAlive(lp_unit) == true)) {

        if ((libCore_gv_zS_SendTransmissionCampaignChatBubbleOn == true)) {

            if ((libNtve_gf_PlayerInCinematicMode(1) == true)) {

                ActorSend(libNtve_gf_MainActorofUnit(lp_unit), "AttachModelOffset ModelAdditionHarness StormTalkIconBubble {Overhead 0} 0.000000,0.000000,0.500000");

            }

            else {

                ActorSend(libNtve_gf_MainActorofUnit(lp_unit), "AttachModelOffset ModelAdditionHarness StormTalkIconBubble {Overhead 0} 0.000000,0.000000,1.8");

            }

            lv_talkBubble = ActorFrom("::LastCreatedActual");

            ActorSend(lv_talkBubble, "AnimPlay Default Birth PlayForever,NonLooping");

            ActorSend(lv_talkBubble, "AnimSetTimeScale Default 0.200000");

            libNtve_gf_AttachModelToUnit(lp_unit, "StormTalkIconRing", "Ref_Origin");

            lv_talkRing = libNtve_gf_ActorLastCreated();

            ActorSend(lv_talkRing, "AnimPlay Default Birth PlayForever,NonLooping");

        }



    }



    TransmissionSendForPlayer(PlayerGroupAll(), lv_source, lv_portrait, lp_portraitActor, "Talk", lp_sound, lp_speaker, lp_message, lp_duration, lp_durationType, lp_waitUntilDone, c_maxPlayers);

    if ((lp_waitUntilDone == false)) {

        libCore_gf_ZS_SendTransmissionCampaignCleanUp(TransmissionLastSent(), lp_keepPortraitVisible, lv_portrait, lv_talkBubble, lv_talkRing, lv_ping, lv_localIndex);

    }

    else {

        libCore_gf_ZS_SendTransmissionCampaignCleanUp(c_invalidTransmissionId, lp_keepPortraitVisible, lv_portrait, lv_talkBubble, lv_talkRing, lv_ping, lv_localIndex);

    }

}



trigger auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp_Trigger = null;

int auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp_lp_transmission;

int auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp_lp_keepPortraitVisible;

int auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp_lp_portrait;

actor auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp_lp_talkIcon;

actor auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp_lp_talkRing;

int auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp_lp_ping;

int auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp_lp_localIndex;



void libCore_gf_ZS_SendTransmissionCampaignCleanUp (int lp_transmission, int lp_keepPortraitVisible, int lp_portrait, actor lp_talkIcon, actor lp_talkRing, int lp_ping, int lp_localIndex) {

    auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp_lp_transmission = lp_transmission;

    auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp_lp_keepPortraitVisible = lp_keepPortraitVisible;

    auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp_lp_portrait = lp_portrait;

    auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp_lp_talkIcon = lp_talkIcon;

    auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp_lp_talkRing = lp_talkRing;

    auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp_lp_ping = lp_ping;

    auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp_lp_localIndex = lp_localIndex;



    if (auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp_Trigger == null) {

        auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp_Trigger = TriggerCreate("auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp_TriggerFunc");

    }



    TriggerExecute(auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp_Trigger, false, false);

}



bool auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp_TriggerFunc (bool testConds, bool runActions) {

    int lp_transmission = auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp_lp_transmission;

    int lp_keepPortraitVisible = auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp_lp_keepPortraitVisible;

    int lp_portrait = auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp_lp_portrait;

    actor lp_talkIcon = auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp_lp_talkIcon;

    actor lp_talkRing = auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp_lp_talkRing;

    int lp_ping = auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp_lp_ping;

    int lp_localIndex = auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp_lp_localIndex;



    // Automatic Variable Declarations

    // Implementation

    if ((lp_transmission != c_invalidTransmissionId)) {

        TransmissionWait(lp_transmission, 0.0);

    }



    Wait(0.75, c_timeReal);

    if ((lp_localIndex != libCore_gv_zS_SendTransmissionCampaignIndex)) {

        if ((libCore_gv_zS_SendTransmissionCampaignPortrait != lp_portrait) && (lp_portrait != c_invalidPortraitId) && (lp_keepPortraitVisible == libCore_ge_TransmissionPortraitOptioins_HidePortraitAfter) && (lp_portrait != PortraitGetGame())) {

            PortraitSetModel(lp_portrait, "MissingPortrait", false);

            PortraitSetVisible(lp_portrait, PlayerGroupAll(), false, false);

        }



        return true;

    }



    libCore_gv_zS_SendTransmissionCampaignIndex = 0;

    libCore_gv_zS_SendTransmissionCampaignSpeaker = null;

    TriggerExecute(libCore_gt__SendTransmissionTick, true, false);

    if ((lp_keepPortraitVisible == libCore_ge_TransmissionPortraitOptioins_HidePortraitAfter) && (lp_portrait != c_invalidPortraitId) && (lp_portrait != PortraitGetGame())) {

        PortraitSetModel(lp_portrait, "MissingPortrait", false);

        PortraitSetVisible(lp_portrait, PlayerGroupAll(), false, false);

    }



    if ((lp_talkIcon != null)) {

        libNtve_gf_KillModel(lp_talkIcon);

    }



    if ((lp_talkRing != null)) {

        libNtve_gf_KillModel(lp_talkRing);

    }



    if ((lp_ping != c_invalidPingId)) {

        PingDestroy(lp_ping);

    }



    return true;

}



void libCore_gf_ZS_SendTransmissionCampaignInternal2 (bool lp_isPlaceHolder, unit lp_unit, string lp_model, soundlink lp_sound, text lp_speaker, text lp_message, int lp_durationType, fixed lp_duration, bool lp_waitUntilDone, int lp_keepPortraitVisible, int lp_cueSoundOption, string lp_portraitActor, int lp_player) {

    // Variable Declarations

    int lv_portrait;

    transmissionsource lv_source;

    int lv_localIndex;

    unit lv_oldSpeaker;

    trigger lv_oldTrigger;

    actor lv_talkBubble;

    actor lv_talkRing;

    int lv_ping;

    bool lv_flashOption;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_portrait = c_invalidPortraitId;

    lv_source = TransmissionSource();

    lv_ping = c_invalidPingId;

    lv_flashOption = true;



    // Implementation

    if ((lp_sound == null)) {

        return ;

    }



    libCore_gv_zS_SendTransmissionCampaignIndex += 1;

    lv_localIndex = libCore_gv_zS_SendTransmissionCampaignIndex;

    lv_oldSpeaker = libCore_gv_zS_SendTransmissionCampaignSpeaker;

    libCore_gv_zS_SendTransmissionCampaignSpeaker = lp_unit;

    lv_oldTrigger = libCore_gv_zS_SendTransmissionCampaignTrigger;

    libCore_gv_zS_SendTransmissionCampaignTrigger = TriggerGetCurrent();

    if ((lp_keepPortraitVisible != libCore_ge_TransmissionPortraitOptioins_DontShowPortrait) && ((lp_model != null) || ((lp_model == null) && (SoundPortraitModel(lp_sound) != null)) || ((lp_isPlaceHolder == true) && (lp_unit != null)))) {

        if ((libNtve_gf_PlayerInCinematicMode(1) == false) && (libNtve_gf_PlayerInStoryMode(1) == false)) {

            lv_portrait = PortraitGetGame();

        }

        else {

            lv_portrait = c_invalidPortraitId;

        }

    }

    else {

        lv_portrait = c_invalidPortraitId;

    }

    if ((lv_portrait != c_invalidPortraitId)) {

        if ((lp_unit != null)) {

            if ((PlayerGroupHasPlayer(libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamOrderIndex_C, true), UnitGetOwner(lp_unit)) == true)) {

                PortraitSetTeamColor(lv_portrait, libNtve_gf_ConvertPlayerColorToColor(2));

            }

            else if ((PlayerGroupHasPlayer(libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamChaosIndex_C, true), UnitGetOwner(lp_unit)) == true)) {

                PortraitSetTeamColor(lv_portrait, libNtve_gf_ConvertPlayerColorToColor(1));

            }

            else if (true) {

                PortraitSetTeamColor(lv_portrait, libNtve_gf_ConvertPlayerColorToColor(0));

            }

        }

        else {

            PortraitSetTeamColor(lv_portrait, libNtve_gf_ConvertPlayerColorToColor(PlayerGetColorIndex(0, false)));

        }

    }



    libCore_gv_zS_SendTransmissionCampaignPortrait = lv_portrait;

    if ((libCore_gv_zS_SendTransmissionCampaignPortrait != c_invalidPortraitId)) {

        PortraitSetVisible(libCore_gv_zS_SendTransmissionCampaignPortrait, PlayerGroupSingle(lp_player), true, false);

    }



    libCore_gv_zS_SendTransmissionCampaignPlayingTick = 3;

    if ((lp_unit == null)) {

        if ((lv_portrait == c_invalidPortraitId)) {

            lv_source = TransmissionSource();

        }

        else {

            if ((lp_model == null)) {

                lv_source = TransmissionSourceFromModel(null);

            }

            else {

                lv_source = TransmissionSourceFromModel(lp_model);

            }

        }

    }

    else {

        if ((libNtve_gf_PlayerInCinematicMode(1) == true)) {

            lv_flashOption = false;

        }

        else {

            lv_flashOption = true;

        }

        if ((lp_isPlaceHolder == false)) {

            lv_source = TransmissionSourceFromUnit(lp_unit, lv_flashOption, false, "Talk");

        }

        else {

            if ((lp_model == null)) {

                if ((UnitGetOwner(EventUnit()) == 1)) {

                    lv_source = TransmissionSourceFromUnit(lp_unit, lv_flashOption, false, "Talk");

                }



            }

            else {

                lv_source = TransmissionSourceFromModel(lp_model);

            }

            lv_source = TransmissionSourceFromModel(lp_model);

        }

    }

    if ((lp_unit != null) && (lp_unit != lv_oldSpeaker) && (UnitIsAlive(lp_unit) == true)) {

        if ((libCore_gv_zS_SendTransmissionCampaignChatBubbleOn == true)) {

            if ((libNtve_gf_PlayerInCinematicMode(1) == true)) {

                ActorSend(libNtve_gf_MainActorofUnit(lp_unit), "AttachModelOffset ModelAdditionHarness StormTalkIconBubble {Overhead 0} 0.000000,0.000000,0.600000");

                lv_talkBubble = ActorFrom("::LastCreatedActual");

                ActorSend(lv_talkBubble, "AnimPlay Default Birth PlayForever,NonLooping");

            }

            else {

                ActorSend(libNtve_gf_MainActorofUnit(lp_unit), "AttachModelOffset ModelAdditionHarness StormTalkIconBubble {Overhead 0} 0.000000,0.000000,1.8");

                lv_talkBubble = ActorFrom("::LastCreatedActual");

                ActorSend(lv_talkBubble, "AnimPlay Default Birth PlayForever,NonLooping");

            }

            libNtve_gf_AttachModelToUnit(lp_unit, "StormTalkIconRing", "Ref_Origin");

            lv_talkRing = libNtve_gf_ActorLastCreated();

            ActorSend(lv_talkRing, "AnimPlay Default Birth PlayForever,NonLooping");

        }



    }



    TransmissionSendForPlayer(PlayerGroupSingle(lp_player), lv_source, lv_portrait, lp_portraitActor, "Talk", lp_sound, lp_speaker, lp_message, lp_duration, lp_durationType, lp_waitUntilDone, c_maxPlayers);

    if ((lp_waitUntilDone == false)) {

        libCore_gf_ZS_SendTransmissionCampaignCleanUp2(TransmissionLastSent(), lp_keepPortraitVisible, lv_portrait, lv_talkBubble, lv_talkRing, lv_ping, lv_localIndex, lp_player);

    }

    else {

        libCore_gf_ZS_SendTransmissionCampaignCleanUp2(c_invalidTransmissionId, lp_keepPortraitVisible, lv_portrait, lv_talkBubble, lv_talkRing, lv_ping, lv_localIndex, lp_player);

    }

}



trigger auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp2_Trigger = null;

int auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp2_lp_transmission;

int auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp2_lp_keepPortraitVisible;

int auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp2_lp_portrait;

actor auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp2_lp_talkIcon;

actor auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp2_lp_talkRing;

int auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp2_lp_ping;

int auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp2_lp_localIndex;

int auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp2_lp_player;



void libCore_gf_ZS_SendTransmissionCampaignCleanUp2 (int lp_transmission, int lp_keepPortraitVisible, int lp_portrait, actor lp_talkIcon, actor lp_talkRing, int lp_ping, int lp_localIndex, int lp_player) {

    auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp2_lp_transmission = lp_transmission;

    auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp2_lp_keepPortraitVisible = lp_keepPortraitVisible;

    auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp2_lp_portrait = lp_portrait;

    auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp2_lp_talkIcon = lp_talkIcon;

    auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp2_lp_talkRing = lp_talkRing;

    auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp2_lp_ping = lp_ping;

    auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp2_lp_localIndex = lp_localIndex;

    auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp2_lp_player = lp_player;



    if (auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp2_Trigger == null) {

        auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp2_Trigger = TriggerCreate("auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp2_TriggerFunc");

    }



    TriggerExecute(auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp2_Trigger, false, false);

}



bool auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp2_TriggerFunc (bool testConds, bool runActions) {

    int lp_transmission = auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp2_lp_transmission;

    int lp_keepPortraitVisible = auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp2_lp_keepPortraitVisible;

    int lp_portrait = auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp2_lp_portrait;

    actor lp_talkIcon = auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp2_lp_talkIcon;

    actor lp_talkRing = auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp2_lp_talkRing;

    int lp_ping = auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp2_lp_ping;

    int lp_localIndex = auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp2_lp_localIndex;

    int lp_player = auto_libCore_gf_ZS_SendTransmissionCampaignCleanUp2_lp_player;



    // Automatic Variable Declarations

    // Implementation

    if ((lp_transmission != c_invalidTransmissionId)) {

        TransmissionWait(lp_transmission, 0.0);

    }



    Wait(0.75, c_timeReal);

    if ((lp_localIndex != libCore_gv_zS_SendTransmissionCampaignIndex)) {

        if ((libCore_gv_zS_SendTransmissionCampaignPortrait != lp_portrait) && (lp_portrait != c_invalidPortraitId) && (lp_keepPortraitVisible == libCore_ge_TransmissionPortraitOptioins_HidePortraitAfter) && (lp_portrait != PortraitGetGame())) {

            PortraitSetModel(lp_portrait, "MissingPortrait", false);

            PortraitSetVisible(lp_portrait, PlayerGroupSingle(lp_player), false, false);

        }



        return true;

    }



    libCore_gv_zS_SendTransmissionCampaignIndex = 0;

    libCore_gv_zS_SendTransmissionCampaignSpeaker = null;

    TriggerExecute(libCore_gt__SendTransmissionTick, true, false);

    if ((lp_keepPortraitVisible == libCore_ge_TransmissionPortraitOptioins_HidePortraitAfter) && (lp_portrait != c_invalidPortraitId) && (lp_portrait != PortraitGetGame())) {

        PortraitSetModel(lp_portrait, "MissingPortrait", false);

        PortraitSetVisible(lp_portrait, PlayerGroupSingle(lp_player), false, false);

    }



    if ((lp_talkIcon != null)) {

        libNtve_gf_KillModel(lp_talkIcon);

    }



    if ((lp_talkRing != null)) {

        libNtve_gf_KillModel(lp_talkRing);

    }



    if ((lp_ping != c_invalidPingId)) {

        PingDestroy(lp_ping);

    }



    return true;

}



void libCore_gf_HideCampaignTransmissionPortrait () {

    // Automatic Variable Declarations

    // Implementation

    libNtve_gf_HideAllCinematicPortraits(PlayerGroupAll());

}



fixed libCore_gf_ConvesationLineDuration (string lp_conversationLine) {

    // Variable Declarations

    soundlink lv_sound;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_sound = SoundLink("EditorDefaultSound", -1);



    // Implementation

    lv_sound = SoundLink(ConversationDataGetSound(lp_conversationLine, true), c_soundIndexAny);

    return SoundLengthSync(lv_sound);

}



void libCore_gf_PlayConvoMultiple (string lp_convo1, playergroup lp_forPlayers1, string lp_convo2, playergroup lp_forPlayers2, string lp_convo3, playergroup lp_forPlayers3, string lp_convo4, playergroup lp_forPlayers4, string lp_convo5, playergroup lp_forPlayers5, int lp_skipOptions) {

    // Variable Declarations

    int lv_itIndex;



    // Automatic Variable Declarations

    // Variable Initialization



    // Implementation

    libCore_gf__PlayConvoMultipleSingle(1, lp_convo1, lp_skipOptions, lp_forPlayers1);

    libCore_gf__PlayConvoMultipleSingle(2, lp_convo2, lp_skipOptions, lp_forPlayers2);

    libCore_gf__PlayConvoMultipleSingle(3, lp_convo3, lp_skipOptions, lp_forPlayers3);

    libCore_gf__PlayConvoMultipleSingle(4, lp_convo4, lp_skipOptions, lp_forPlayers4);

    libCore_gf__PlayConvoMultipleSingle(5, lp_convo5, lp_skipOptions, lp_forPlayers5);

}



trigger auto_libCore_gf__PlayConvoMultipleSingle_Trigger = null;

int auto_libCore_gf__PlayConvoMultipleSingle_lp_convoMultipleIndex;

string auto_libCore_gf__PlayConvoMultipleSingle_lp_dataConvo;

int auto_libCore_gf__PlayConvoMultipleSingle_lp_skipOptions;

playergroup auto_libCore_gf__PlayConvoMultipleSingle_lp_forPlayers;



void libCore_gf__PlayConvoMultipleSingle (int lp_convoMultipleIndex, string lp_dataConvo, int lp_skipOptions, playergroup lp_forPlayers) {

    auto_libCore_gf__PlayConvoMultipleSingle_lp_convoMultipleIndex = lp_convoMultipleIndex;

    auto_libCore_gf__PlayConvoMultipleSingle_lp_dataConvo = lp_dataConvo;

    auto_libCore_gf__PlayConvoMultipleSingle_lp_skipOptions = lp_skipOptions;

    auto_libCore_gf__PlayConvoMultipleSingle_lp_forPlayers = lp_forPlayers;



    if (auto_libCore_gf__PlayConvoMultipleSingle_Trigger == null) {

        auto_libCore_gf__PlayConvoMultipleSingle_Trigger = TriggerCreate("auto_libCore_gf__PlayConvoMultipleSingle_TriggerFunc");

    }



    TriggerExecute(auto_libCore_gf__PlayConvoMultipleSingle_Trigger, false, false);

}



bool auto_libCore_gf__PlayConvoMultipleSingle_TriggerFunc (bool testConds, bool runActions) {

    int lp_convoMultipleIndex = auto_libCore_gf__PlayConvoMultipleSingle_lp_convoMultipleIndex;

    string lp_dataConvo = auto_libCore_gf__PlayConvoMultipleSingle_lp_dataConvo;

    int lp_skipOptions = auto_libCore_gf__PlayConvoMultipleSingle_lp_skipOptions;

    playergroup lp_forPlayers = auto_libCore_gf__PlayConvoMultipleSingle_lp_forPlayers;



    // Automatic Variable Declarations

    // Implementation

    libCore_gv__ConvoMultipleFinished[lp_convoMultipleIndex] = false;

    if ((lp_dataConvo != null)) {

        ConversationDataRun(lp_dataConvo, lp_forPlayers, lp_skipOptions, true);

    }



    libCore_gv__ConvoMultipleFinished[lp_convoMultipleIndex] = true;

    return true;

}



string libCore_gf_ConvoLineName (int lp_index) {

    // Variable Declarations

    string lv_name;

    string lv_subName;

    int lv_length;

    int lv_subLength;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_name = "";

    lv_subName = "";



    // Implementation

    lv_name = "Line00000";

    lv_subName = IntToString(lp_index);

    lv_length = StringLength(lv_name);

    lv_subLength = StringLength(lv_subName);

    lv_name = StringReplace(lv_name, lv_subName, (lv_length-lv_subLength+1), lv_length);

    return lv_name;

}



void libCore_gf_WaitForConversationToFinish () {

    // Variable Declarations

    int lv_itPlayer;

    playergroup lv_players;

    bool lv_finished;



    // Automatic Variable Declarations

    playergroup autoBB4504D2_g;



    // Variable Initialization

    lv_players = PlayerGroupEmpty();



    // Implementation

    libNtve_gf_AddPlayerGroupToPlayerGroup(libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamOrderIndex_C, false), lv_players);

    libNtve_gf_AddPlayerGroupToPlayerGroup(libGame_gf_PlayersOnTeamHeroes(libGame_gv_teamChaosIndex_C, false), lv_players);

    libNtve_gf_AddPlayerGroupToPlayerGroup(libCore_gv_playerGroupFromPlayer[libCore_gv_oBSERVER_ObserverUIPlayer], lv_players);

    while (true) {

        lv_finished = true;

        autoBB4504D2_g = lv_players;

        lv_itPlayer = -1;

        while (true) {

            	lv_itPlayer = PlayerGroupNextPlayer(autoBB4504D2_g, lv_itPlayer);

            	if (lv_itPlayer<0) { break; }

            	if ((TransmissionPlayerHasActiveTransmission(lv_itPlayer) == true)) {

                lv_finished = false;

                break;

            }



        }

        if ((lv_finished == true)) {

            return ;

        }



        Wait(0.5, c_timeGame);

    }

}



void libCore_gf_AutoRevealRegion (region lp_visibilityRegion, region lp_triggeringRegion, int lp_player) {

    // Automatic Variable Declarations

    // Implementation

    if ((libCore_gv_autoRevealers.lv_count >= 64)) {

        return ;

    }



    VisRevealerCreate(lp_player, lp_visibilityRegion);

    libCore_gv_autoRevealers.lv_revealers[libCore_gv_autoRevealers.lv_count] = VisRevealerLastCreated();

    VisRevealerEnable(VisRevealerLastCreated(), false);

    libCore_gv_autoRevealers.lv_triggeringRegions[libCore_gv_autoRevealers.lv_count] = lp_triggeringRegion;

    libCore_gv_autoRevealers.lv_triggeringPlayers[libCore_gv_autoRevealers.lv_count] = lp_player;

    libCore_gv_autoRevealers.lv_count += 1;

    TriggerExecute(libCore_gt_AutoRevealRegionController, true, false);

}



// Triggers

//--------------------------------------------------------------------------------------------------

// Trigger: #Include Core

//--------------------------------------------------------------------------------------------------

bool libCore_gt_IncludeCore_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    return true;

}



//--------------------------------------------------------------------------------------------------

void libCore_gt_IncludeCore_Init () {

    libCore_gt_IncludeCore = TriggerCreate("libCore_gt_IncludeCore_Func");

}



//--------------------------------------------------------------------------------------------------

// Trigger: Data - Announcer VO - Map Data Fields

//--------------------------------------------------------------------------------------------------

bool libCore_gt_DataAnnouncerVOMapDataFields_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Actions

    if (!runActions) {

        return true;

    }



    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_GetReadyForBattle, "HeroSelect", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_BattleStartingIn, "CountdownRemain", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_Countdown10, "Countdown10sec", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_Countdown5, "Countdown5sec", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_Countdown4, "Countdown4sec", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_Countdown3, "Countdown3sec", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_Countdown2, "Countdown2sec", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_Countdown1, "Countdown1sec", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_LetTheBattleBegin, "GameStart", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_YouHaveBeenKilled, "HeroSlain", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_AllyKilled, "AllySlain", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_EnemyKilledNonparticipants, "EnemySlain", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_EnemyKilledParticipants, "HeroKill", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_HeroKilledObserver, "Kill_Observer", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_DoubleKill, "DoubleKill", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_TripleKill, "TripleKill", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_QuadraKill, "FourKill", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_MegaKill, "MegaKill", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_SixKill, "SixKill", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_SevenKill, "SevenKill", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_EightKill, "EightKill", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_NineKill, "NineKill", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_TenKill, "TenKill", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_BlueTeamKilled, "TeamKill_Blue", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_RedTeamKilled, "TeamKill_Red", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_AllyFirstBlood, "FirstBloodAlly", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_EnemyFirstBlood, "FirstBloodEnemy", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_BlueTeamFirstBlood, "FirstBlood_Blue", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_RedTeamFirstBlood, "FirstBlood_Red", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_KillingSpreeStart, "SpreeStart", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_KillingSpreeEndYou, "SpreeEnd", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_KillingSpreeUpgrade1Mayhem, "SpreeFirstUpgrade", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_KillingSpreeUpgrade2Untouchable, "SpreeThirdUpgrade", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_KillingSpreeUpgrade3HeroOfTheStorm, "SpreeMax", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_KillingSpreeUpgrade4AllStarDEP, "SpreeMax", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_APlayerHasLeftTheGame, "PlayerAbandon", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_APlayerHasRejoinedTheGame, "PlayerRejoin", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_GravestoneRevive, "Revive", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_AlliedOutpostDestroyed, "OutpostLost", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_EnemyOutpostDestroyed, "OutpostDestroy", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_AlliedKeepDestroyed, "KeepLost", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_EnemyKeepDestroyed, "KeepDestroy", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_RedTeamDestroysTown, "OutpostDestroy_Red", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_BlueTeamDestroysTown, "OutpostDestroy_Blue", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_AlliedCoreUnderAttack, "CastleAttackAlly", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_BlueTeamCoreUnderAttack, "CastleAttack_Blue", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_RedTeamCoreUnderAttack, "CastleAttack_Red", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_Victory, "EndingWin", true);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_Defeat, "EndingLose", true);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_BlueTeamWins, "Ending_Blue", true);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_RedTeamWins, "Ending_Red", true);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_AlliesCaptureMercCamp, "MercCapture", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_EnemiesCaptureMercCamp, "MercCapture", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_BlueTeamCapturesMercCamp, "MercCapture_Blue", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_RedTeamCapturesMercCamp, "MercCapture_Red", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_LevelUp, "LevelAnnounce", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_TalentUnlocked, "TalentUnlock", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_GamePaused, "GamePaused", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_GameResumed, "GameResumed", false);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_MVP, "MVP", true);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_MVPVoteEpic, "MVP Vote Epic", true);

    libCore_gf_DataAnnouncerVOMapDataField(libCore_ge_AnnouncerVOEvents_MVPVoteLegendary, "MVP Vote Legendary", true);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libCore_gt_DataAnnouncerVOMapDataFields_Init () {

    libCore_gt_DataAnnouncerVOMapDataFields = TriggerCreate("libCore_gt_DataAnnouncerVOMapDataFields_Func");

}



//--------------------------------------------------------------------------------------------------

// Trigger: Data - Heroes - Hero Data

//--------------------------------------------------------------------------------------------------

bool libCore_gt_DataHeroesHeroData_Func (bool testConds, bool runActions) {

    // Variable Declarations

    string lv_heroID;

    int lv_itHeroIndex;

    int lv_classInt;

    int lv_classCount;

    string lv_previousHeroID;



    // Automatic Variable Declarations

    int auto4FFE58C7_ae;

    const int auto4FFE58C7_ai = 1;



    // Variable Initialization

    lv_heroID = "";

    lv_previousHeroID = "";



    // Actions

    if (!runActions) {

        return true;

    }



    libCore_gv_heroes_RandomHeroID = (CatalogFieldValueGet(c_gameCatalogConfig, "Config", "RandomHero", c_playerAny));

    libCore_gv_heroes_RandomSkinID = (CatalogFieldValueGet(c_gameCatalogConfig, "Config", "RandomSkin", c_playerAny));

    libCore_gv_heroes_RandomMountID = (CatalogFieldValueGet(c_gameCatalogConfig, "Config", "RandomMount", c_playerAny));

    libCore_gv_dataHeroesNumberOfHeroes = CatalogFieldValueCount(c_gameCatalogConfig, "Config", "HeroArray", c_playerAny);

    auto4FFE58C7_ae = libCore_gv_dataHeroesNumberOfHeroes;

    lv_itHeroIndex = 1;

    for ( ; ( (auto4FFE58C7_ai >= 0 && lv_itHeroIndex <= auto4FFE58C7_ae) || (auto4FFE58C7_ai < 0 && lv_itHeroIndex >= auto4FFE58C7_ae) ) ; lv_itHeroIndex += auto4FFE58C7_ai ) {

        lv_heroID = CatalogFieldValueGet(c_gameCatalogConfig, "Config", "HeroArray[" + IntToString((lv_itHeroIndex - 1)) + "]", c_playerAny);

        if ((lv_heroID == "")) {

            TextExpressionSetToken("Param/Expression/lib_Core_62EAE737", "A", StringToText(lv_previousHeroID));

            UIDisplayMessage(PlayerGroupAll(), c_messageAreaSubtitle, TextExpressionAssemble("Param/Expression/lib_Core_62EAE737"));

            lv_heroID = "TestHero";

        }



        lv_classInt = CatalogFieldValueGetAsInt(c_gameCatalogHero, lv_heroID, "Role", c_playerAny);

        lv_classCount = DataTableGetInt(true, ("Heroes_HeroClass_" + IntToString(lv_classInt) + "_HeroCount"));

        lv_classCount += 1;

        DataTableSetInt(true, ("Heroes_HeroClass_" + IntToString(lv_classInt) + "_HeroCount"), lv_classCount);

        DataTableSetInt(true, ("Heroes_HeroClass_" + IntToString(lv_classInt) + "_Index_" + IntToString(lv_classCount) + "_Index"), lv_itHeroIndex);

        libCore_gf_DataHeroesAddHeroIDToDataTable(lv_itHeroIndex, (lv_heroID));

        lv_previousHeroID = lv_heroID;

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libCore_gt_DataHeroesHeroData_Init () {

    libCore_gt_DataHeroesHeroData = TriggerCreate("libCore_gt_DataHeroesHeroData_Func");

}



//--------------------------------------------------------------------------------------------------

// Trigger: Data - Hero VO - Map Data Fields

//--------------------------------------------------------------------------------------------------

bool libCore_gt_DataHeroVOMapDataFields_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Actions

    if (!runActions) {

        return true;

    }



    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_Revive, "Revive");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_Healed, "Healed");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_Resurrected, "Resurrected");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_Pissed, "Pissed");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_GenericKill, "KillGeneric");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_TeamKilled, "TeamKilled");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_Laugh, "Laugh");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_No, "No");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_EndEnemyKillingSpree, "EndEnemyKillSpree");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_TalentChosen, "SpecChosen");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_Celebrate, "Celebrate");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_WorthIt, "WorthIt");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_Comeback, "Comeback");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_AIRetreat, "AIRetreat");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_AIGoodJob, "AIGoodJob");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_AIOnMyWay, "AIOnMyWay");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_AIMercCapture, "AIMercCapture");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_AICaution, "AICaution");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_AIAttack, "AIAttack");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_AIUhOh, "AIUhOh");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_AIHeal, "AIHeal");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_PingAttackHere, "PingAttackHere");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_PingDefendHere, "PingDefendHere");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_PingAttackTown, "PingAttackTown");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_PingDefendTown, "PingDefendTown");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_PingAttackWatchTower, "PingAttackWatchTower");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_PingDefendWatchTower, "PingDefendWatchTower");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_PingAttackCore, "PingAttackCore");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_PingDefendCore, "PingDefendCore");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_PingAttackMercCamp, "PingAttackMercCamp");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_PingKillHero, "PingAttackHero");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_PingAssistHero, "PingAssistHero");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_PingAssistMe, "PingAssistMe");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_PingEnemyMissing, "PingEnemyMissing");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_IntroQuestion, "IntroQuestion");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_IntroResponse, "IntroResponse");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_IntroBoast, "IntroBoast");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_IntroAgree, "IntroAgree");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_VOXGetHit, "GetHit");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_VOXGetHitLarge, "GetHitLarge");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_VOXGetHitSmall, "GetHitSmall");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_Hello, "Hello");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_Thanks, "Thanks");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_WellPlayed, "WellPlayed");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_Sorry, "Sorry");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_Goodbye, "Goodbye");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_Cheer, "Cheer");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_GlueTrial, "GlueTrial");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_VOPing_AssistMe, "VOPing_AssistMe");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_VOPing_Danger, "VOPing_Danger");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_VOPing_Defend, "VOPing_Defend");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_VOPing_EnemyMissing, "VOPing_EnemyMissing");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_VOPing_OnMyWay, "VOPing_OnMyWay");

    libCore_gf_DataHeroVOMapDataField(libCore_ge_HeroVOEvents_VOPing_Retreat, "VOPing_Retreat");

    return true;

}



//--------------------------------------------------------------------------------------------------

void libCore_gt_DataHeroVOMapDataFields_Init () {

    libCore_gt_DataHeroVOMapDataFields = TriggerCreate("libCore_gt_DataHeroVOMapDataFields_Func");

}



//--------------------------------------------------------------------------------------------------

// Trigger: Data - Initialize Spray Data

//--------------------------------------------------------------------------------------------------

bool libCore_gt_DataInitializeSprayData_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_itSpray;

    string lv_sprayID;



    // Automatic Variable Declarations

    int auto5428BB10_ae;

    const int auto5428BB10_ai = 1;



    // Variable Initialization

    lv_sprayID = "";



    // Actions

    if (!runActions) {

        return true;

    }



    auto5428BB10_ae = CatalogEntryCount(c_gameCatalogSpray);

    lv_itSpray = 1;

    for ( ; ( (auto5428BB10_ai >= 0 && lv_itSpray <= auto5428BB10_ae) || (auto5428BB10_ai < 0 && lv_itSpray >= auto5428BB10_ae) ) ; lv_itSpray += auto5428BB10_ai ) {

        lv_sprayID = (CatalogEntryGet(c_gameCatalogSpray, lv_itSpray));

        if ((lv_sprayID != ("RandomSpray"))) {

            libCore_gv_loot_SprayCount += 1;

            DataTableSetString(true, ("SprayIndex_" + IntToString(libCore_gv_loot_SprayCount)), lv_sprayID);

        }



    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libCore_gt_DataInitializeSprayData_Init () {

    libCore_gt_DataInitializeSprayData = TriggerCreate("libCore_gt_DataInitializeSprayData_Func");

}



//--------------------------------------------------------------------------------------------------

// Trigger: Data - Initialize Banner Data

//--------------------------------------------------------------------------------------------------

bool libCore_gt_DataInitializeBannerData_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_itBanner;

    string lv_bannerID;



    // Automatic Variable Declarations

    int autoC8805FFB_ae;

    const int autoC8805FFB_ai = 1;



    // Variable Initialization

    lv_bannerID = "";



    // Actions

    if (!runActions) {

        return true;

    }



    autoC8805FFB_ae = CatalogEntryCount(c_gameCatalogBanner);

    lv_itBanner = 1;

    for ( ; ( (autoC8805FFB_ai >= 0 && lv_itBanner <= autoC8805FFB_ae) || (autoC8805FFB_ai < 0 && lv_itBanner >= autoC8805FFB_ae) ) ; lv_itBanner += autoC8805FFB_ai ) {

        lv_bannerID = (CatalogEntryGet(c_gameCatalogBanner, lv_itBanner));

        if ((lv_bannerID != ("RandomBanner"))) {

            libCore_gv_loot_BannerCount += 1;

            DataTableSetString(true, ("BannerIndex_" + IntToString(libCore_gv_loot_BannerCount)), lv_bannerID);

        }



    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libCore_gt_DataInitializeBannerData_Init () {

    libCore_gt_DataInitializeBannerData = TriggerCreate("libCore_gt_DataInitializeBannerData_Func");

}



//--------------------------------------------------------------------------------------------------

// Trigger: Data - Initialize Announcer Pack Data

//--------------------------------------------------------------------------------------------------

bool libCore_gt_DataInitializeAnnouncerPackData_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_itAnnouncerPack;

    string lv_announcerPackID;



    // Automatic Variable Declarations

    int auto997AC270_ae;

    const int auto997AC270_ai = 1;



    // Variable Initialization

    lv_announcerPackID = "";



    // Actions

    if (!runActions) {

        return true;

    }



    auto997AC270_ae = CatalogEntryCount(c_gameCatalogAnnouncerPack);

    lv_itAnnouncerPack = 1;

    for ( ; ( (auto997AC270_ai >= 0 && lv_itAnnouncerPack <= auto997AC270_ae) || (auto997AC270_ai < 0 && lv_itAnnouncerPack >= auto997AC270_ae) ) ; lv_itAnnouncerPack += auto997AC270_ai ) {

        lv_announcerPackID = (CatalogEntryGet(c_gameCatalogAnnouncerPack, lv_itAnnouncerPack));

        if ((lv_announcerPackID != ("RandomAnnouncerPack"))) {

            libCore_gv_loot_AnnouncerPackCount += 1;

            DataTableSetString(true, ("AnnouncerPackIndex_" + IntToString(libCore_gv_loot_AnnouncerPackCount)), lv_announcerPackID);

        }



    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libCore_gt_DataInitializeAnnouncerPackData_Init () {

    libCore_gt_DataInitializeAnnouncerPackData = TriggerCreate("libCore_gt_DataInitializeAnnouncerPackData_Func");

}



//--------------------------------------------------------------------------------------------------

// Trigger: Data - Minion Scaling Data

//--------------------------------------------------------------------------------------------------

bool libCore_gt_DataMinionScalingData_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((libCore_gv_sYSCustomMinionsEnabled == false))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libCore_gf_DataInitializeScalingDataForMinion("FootmanMinion", libCore_ge_MinionTypes_Footmen);

    libCore_gf_DataInitializeScalingDataForMinion("WizardMinion", libCore_ge_MinionTypes_Wizard);

    libCore_gf_DataInitializeScalingDataForMinion("RangedMinion", libCore_ge_MinionTypes_Ranged);

    libCore_gf_DataInitializeScalingDataForMinion("CatapultMinion", libCore_ge_MinionTypes_Catapult);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libCore_gt_DataMinionScalingData_Init () {

    libCore_gt_DataMinionScalingData = TriggerCreate("libCore_gt_DataMinionScalingData_Func");

}



//--------------------------------------------------------------------------------------------------

// Trigger: Data - Minion Wave Composition Data

//--------------------------------------------------------------------------------------------------

bool libCore_gt_DataMinionWaveCompositionData_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_composition;

    int lv_group;



    // Automatic Variable Declarations

    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((libCore_gv_sYSCustomMinionsEnabled == false))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    lv_composition = (libCore_ge_MinionWaveCompositionsTypes_Standard);

    lv_group = 0;

    libCore_gv_dataMinionWaveCompositions[lv_composition].lv_name = StringExternal("Param/Value/lib_Core_A78308CE");

    libCore_gv_dataMinionWaveCompositions[lv_composition].lv_enabled = true;

    lv_group += 1;

    libCore_gv_dataMinionWaveCompositions[lv_composition].lv_groupMinionType[lv_group] = libCore_ge_MinionTypes_Footmen;

    libCore_gv_dataMinionWaveCompositions[lv_composition].lv_groupMinionCount[lv_group] = 3;

    lv_group += 1;

    libCore_gv_dataMinionWaveCompositions[lv_composition].lv_groupMinionType[lv_group] = libCore_ge_MinionTypes_Wizard;

    libCore_gv_dataMinionWaveCompositions[lv_composition].lv_groupMinionCount[lv_group] = 1;

    lv_group += 1;

    libCore_gv_dataMinionWaveCompositions[lv_composition].lv_groupMinionType[lv_group] = libCore_ge_MinionTypes_Ranged;

    libCore_gv_dataMinionWaveCompositions[lv_composition].lv_groupMinionCount[lv_group] = 3;

    lv_group += 1;

    libCore_gv_dataMinionWaveCompositions[lv_composition].lv_groupMinionType[lv_group] = libCore_ge_MinionTypes_Catapult;

    libCore_gv_dataMinionWaveCompositions[lv_composition].lv_groupMinionCount[lv_group] = 1;

    libCore_gv_dataMinionWaveCompositions[lv_composition].lv_numberOfGroups = lv_group;

    return true;

}



//--------------------------------------------------------------------------------------------------

void libCore_gt_DataMinionWaveCompositionData_Init () {

    libCore_gt_DataMinionWaveCompositionData = TriggerCreate("libCore_gt_DataMinionWaveCompositionData_Func");

}



//--------------------------------------------------------------------------------------------------

// Trigger: Data - Initialize Mount Data

//--------------------------------------------------------------------------------------------------

bool libCore_gt_DataInitializeMountData_Func (bool testConds, bool runActions) {

    // Variable Declarations

    string lv_mountLink;

    int lv_itMount;



    // Automatic Variable Declarations

    int autoEE185B55_ae;

    const int autoEE185B55_ai = 1;



    // Variable Initialization



    // Actions

    if (!runActions) {

        return true;

    }



    autoEE185B55_ae = CatalogFieldValueCount(c_gameCatalogConfig, "Config", "MountArray", c_playerAny);

    lv_itMount = 1;

    for ( ; ( (autoEE185B55_ai >= 0 && lv_itMount <= autoEE185B55_ae) || (autoEE185B55_ai < 0 && lv_itMount >= autoEE185B55_ae) ) ; lv_itMount += autoEE185B55_ai ) {

        lv_mountLink = (CatalogFieldValueGet(c_gameCatalogConfig, "Config", "MountArray[" + IntToString((lv_itMount - 1)) + "].Mount", c_playerAny));

        libCore_gf_DataMountsAddMountIDToDataTable(lv_mountLink, lv_itMount, 0);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libCore_gt_DataInitializeMountData_Init () {

    libCore_gt_DataInitializeMountData = TriggerCreate("libCore_gt_DataInitializeMountData_Func");

}



//--------------------------------------------------------------------------------------------------

// Trigger: Data - Death Times

//--------------------------------------------------------------------------------------------------

bool libCore_gt_DataDeathTimes_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Actions

    if (!runActions) {

        return true;

    }



    libCore_gv_bALDeathTimes[1] = 15.0;

    libCore_gv_bALDeathTimes[2] = 16.0;

    libCore_gv_bALDeathTimes[3] = 17.0;

    libCore_gv_bALDeathTimes[4] = 18.0;

    libCore_gv_bALDeathTimes[5] = 19.0;

    libCore_gv_bALDeathTimes[6] = 20.0;

    libCore_gv_bALDeathTimes[7] = 22.0;

    libCore_gv_bALDeathTimes[8] = 24.0;

    libCore_gv_bALDeathTimes[9] = 25.0;

    libCore_gv_bALDeathTimes[10] = 27.0;

    libCore_gv_bALDeathTimes[11] = 29.0;

    libCore_gv_bALDeathTimes[12] = 31.0;

    libCore_gv_bALDeathTimes[13] = 34.0;

    libCore_gv_bALDeathTimes[14] = 36.0;

    libCore_gv_bALDeathTimes[15] = 39.0;

    libCore_gv_bALDeathTimes[16] = 41.0;

    libCore_gv_bALDeathTimes[17] = 44.0;

    libCore_gv_bALDeathTimes[18] = 48.0;

    libCore_gv_bALDeathTimes[19] = 51.0;

    libCore_gv_bALDeathTimes[20] = 54.0;

    libCore_gv_bALDeathTimes[21] = 59.0;

    libCore_gv_bALDeathTimes[22] = 65.0;

    libCore_gv_bALDeathTimes[23] = 70.0;

    libCore_gv_bALDeathTimes[24] = 70.0;

    libCore_gv_bALDeathTimes[25] = 70.0;

    libCore_gv_bALDeathTimes[26] = 70.0;

    libCore_gv_bALDeathTimes[27] = 70.0;

    libCore_gv_bALDeathTimes[28] = 70.0;

    libCore_gv_bALDeathTimes[29] = 70.0;

    libCore_gv_bALDeathTimes[30] = 70.0;

    libCore_gv_bALMaxDeathTime = libCore_gv_bALDeathTimes[libCore_gv_bALMaxLevel];

    return true;

}



//--------------------------------------------------------------------------------------------------

void libCore_gt_DataDeathTimes_Init () {

    libCore_gt_DataDeathTimes = TriggerCreate("libCore_gt_DataDeathTimes_Func");

}



//--------------------------------------------------------------------------------------------------

// Trigger: Brett Timers - Set Variables

//--------------------------------------------------------------------------------------------------

bool libCore_gt_BrettTimersSetVariables_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    TriggerDebugOutput(1, StringExternal("Param/Value/lib_Core_01538C0F"), true);

    libCore_gv_brettTimersEnabled = true;

    libCore_gv_bALDeathTimes[1] = 5.0;

    libCore_gv_bALDeathTimes[2] = 5.0;

    libCore_gv_bALDeathTimes[3] = 5.0;

    libCore_gv_bALDeathTimes[4] = 5.0;

    libCore_gv_bALDeathTimes[5] = 5.0;

    libCore_gv_bALDeathTimes[6] = 6.0;

    libCore_gv_bALDeathTimes[7] = 8.0;

    libCore_gv_bALDeathTimes[8] = 10.0;

    libCore_gv_bALDeathTimes[9] = 12.0;

    libCore_gv_bALDeathTimes[10] = 14.0;

    libCore_gv_bALDeathTimes[11] = 16.0;

    libCore_gv_bALDeathTimes[12] = 18.0;

    libCore_gv_bALDeathTimes[13] = 20.0;

    libCore_gv_bALDeathTimes[14] = 22.0;

    libCore_gv_bALDeathTimes[15] = 25.0;

    libCore_gv_bALDeathTimes[16] = 28.0;

    libCore_gv_bALDeathTimes[17] = 31.0;

    libCore_gv_bALDeathTimes[18] = 34.0;

    libCore_gv_bALDeathTimes[19] = 37.0;

    libCore_gv_bALDeathTimes[20] = 40.0;

    libCore_gv_bALDeathTimes[21] = 40.0;

    libCore_gv_bALDeathTimes[22] = 40.0;

    libCore_gv_bALDeathTimes[23] = 40.0;

    libCore_gv_bALDeathTimes[24] = 40.0;

    libCore_gv_bALDeathTimes[25] = 40.0;

    libCore_gv_bALDeathTimes[26] = 40.0;

    libCore_gv_bALDeathTimes[27] = 40.0;

    libCore_gv_bALDeathTimes[28] = 40.0;

    libCore_gv_bALDeathTimes[29] = 40.0;

    libCore_gv_bALDeathTimes[30] = 40.0;

    libCore_gv_bALMaxDeathTime = libCore_gv_bALDeathTimes[libCore_gv_bALMaxLevel];

    return true;

}



//--------------------------------------------------------------------------------------------------

void libCore_gt_BrettTimersSetVariables_Init () {

    libCore_gt_BrettTimersSetVariables = TriggerCreate("libCore_gt_BrettTimersSetVariables_Func");

    TriggerAddEventChatMessage(libCore_gt_BrettTimersSetVariables, c_playerAny, "-bretttimers", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: Brett Timers - Check Death Timer Mod

//--------------------------------------------------------------------------------------------------

bool libCore_gt_BrettTimersCheckDeathTimerMod_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_player;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_player = EventPlayer();



    // Conditions

    if (testConds) {

        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    TextExpressionSetToken("Param/Expression/lib_Core_D9E58343", "B", IntToText(lv_player));

    TextExpressionSetToken("Param/Expression/lib_Core_D9E58343", "A", FixedToText(libGame_gv_players[lv_player].lv_brettTimersTimeMod, 2));

    TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_Core_D9E58343"), true);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libCore_gt_BrettTimersCheckDeathTimerMod_Init () {

    libCore_gt_BrettTimersCheckDeathTimerMod = TriggerCreate("libCore_gt_BrettTimersCheckDeathTimerMod_Func");

    TriggerAddEventChatMessage(libCore_gt_BrettTimersCheckDeathTimerMod, c_playerAny, "-mybretttimer", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: Brett Timers - Takedown Participation

//--------------------------------------------------------------------------------------------------

bool libCore_gt_BrettTimersTakedownParticipation_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_player;

    int lv_lastHitPlayer;



    // Automatic Variable Declarations

    // Variable Initialization

    lv_player = libGame_gf_HeroParticipatedInTakedownKillingPlayer();

    lv_lastHitPlayer = libGame_gf_HeroParticipatedInTakedownLastHitPlayer();



    // Conditions

    if (testConds) {

        if (!((libCore_gv_brettTimersEnabled == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    libGame_gv_players[lv_player].lv_brettTimersTimeMod += libCore_gv_brettTimersTakedownModifier;

    if ((lv_lastHitPlayer == lv_player)) {

        libGame_gv_players[lv_player].lv_brettTimersTimeMod += libCore_gv_brettTimersKillModifier;

    }



    return true;

}



//--------------------------------------------------------------------------------------------------

void libCore_gt_BrettTimersTakedownParticipation_Init () {

    libCore_gt_BrettTimersTakedownParticipation = TriggerCreate("libCore_gt_BrettTimersTakedownParticipation_Func");

    libGame_gf_HeroParticipatedInTakedown(libCore_gt_BrettTimersTakedownParticipation);

}



//--------------------------------------------------------------------------------------------------

// Trigger: Data - Initialize Skin Data

//--------------------------------------------------------------------------------------------------

bool libCore_gt_DataInitializeSkinData_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_itSkin;

    int lv_itMountCategory;

    string lv_skinID;

    string lv_mountCategoryID;

    string lv_skinMountCategoryCountStr;

    int lv_itSkinAddedMountCategory;



    // Automatic Variable Declarations

    int auto10BE01FC_ae;

    const int auto10BE01FC_ai = 1;

    int auto8194357C_ae;

    const int auto8194357C_ai = 1;



    // Variable Initialization

    lv_skinID = "";

    lv_mountCategoryID = "";

    lv_skinMountCategoryCountStr = "";



    // Actions

    if (!runActions) {

        return true;

    }



    libCore_gv_dataSkinsSkinCount += 1;

    DataTableSetString(true, "SkinIndex_1", "Default");

    auto10BE01FC_ae = CatalogEntryCount(c_gameCatalogSkin);

    lv_itSkin = 1;

    for ( ; ( (auto10BE01FC_ai >= 0 && lv_itSkin <= auto10BE01FC_ae) || (auto10BE01FC_ai < 0 && lv_itSkin >= auto10BE01FC_ae) ) ; lv_itSkin += auto10BE01FC_ai ) {

        lv_skinID = (CatalogEntryGet(c_gameCatalogSkin, lv_itSkin));

        libCore_gv_dataSkinsSkinCount += 1;

        DataTableSetString(true, ("SkinIndex_" + IntToString(libCore_gv_dataSkinsSkinCount)), lv_skinID);

        lv_skinMountCategoryCountStr = ("SkinIndex_" + IntToString(libCore_gv_dataSkinsSkinCount) + "_MountCategoryCount");

        auto8194357C_ae = CatalogFieldValueCount(c_gameCatalogSkin, (lv_skinID), "AdditionalMountCategoryArray", c_playerAny);

        lv_itSkinAddedMountCategory = 1;

        for ( ; ( (auto8194357C_ai >= 0 && lv_itSkinAddedMountCategory <= auto8194357C_ae) || (auto8194357C_ai < 0 && lv_itSkinAddedMountCategory >= auto8194357C_ae) ) ; lv_itSkinAddedMountCategory += auto8194357C_ai ) {

            lv_mountCategoryID = CatalogFieldValueGet(c_gameCatalogSkin, lv_skinID, "AdditionalMountCategoryArray[" + IntToString((lv_itSkinAddedMountCategory - 1)) + "]", c_playerAny);

            DataTableSetInt(true, lv_skinMountCategoryCountStr, (DataTableGetInt(true, lv_skinMountCategoryCountStr) + 1));

            DataTableSetString(true, ("SkinIndex_" + IntToString(libCore_gv_dataSkinsSkinCount) + "_MountCategoryIndex_" + IntToString(DataTableGetInt(true, lv_skinMountCategoryCountStr))), lv_mountCategoryID);

        }

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libCore_gt_DataInitializeSkinData_Init () {

    libCore_gt_DataInitializeSkinData = TriggerCreate("libCore_gt_DataInitializeSkinData_Func");

}



//--------------------------------------------------------------------------------------------------

// Trigger: Data - Enable Granular Bounty XP Math Display

//--------------------------------------------------------------------------------------------------

bool libCore_gt_DataEnableGranularBountyXPMathDisplay_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Actions

    if (!runActions) {

        return true;

    }



    libCore_gv_dataXPGranularBountyXPMathDisplayEnabled = true;

    return true;

}



//--------------------------------------------------------------------------------------------------

void libCore_gt_DataEnableGranularBountyXPMathDisplay_Init () {

    libCore_gt_DataEnableGranularBountyXPMathDisplay = TriggerCreate("libCore_gt_DataEnableGranularBountyXPMathDisplay_Func");

    TriggerAddEventChatMessage(libCore_gt_DataEnableGranularBountyXPMathDisplay, c_playerAny, "-showxpmath", true);

}



//--------------------------------------------------------------------------------------------------

// Trigger: Data - XP - Initialize Level XP Values

//--------------------------------------------------------------------------------------------------

bool libCore_gt_DataXPInitializeLevelXPValues_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_level;

    fixed lv_totalXP;



    // Automatic Variable Declarations

    const int auto546944EC_ae = libCore_gv_bALMaxLevel;

    const int auto546944EC_ai = 1;



    // Variable Initialization



    // Actions

    if (!runActions) {

        return true;

    }



    lv_level = 1;

    for ( ; ( (auto546944EC_ai >= 0 && lv_level <= auto546944EC_ae) || (auto546944EC_ai < 0 && lv_level >= auto546944EC_ae) ) ; lv_level += auto546944EC_ai ) {

        lv_totalXP += CatalogFieldValueGetAsFixed(c_gameCatalogBehavior, "HeroXPCurve", "VeterancyLevelArray[" + IntToString((lv_level - 1)) + "].MinVeterancyXP", c_playerAny);

        libCore_gv_dataXPLevelXPValues[lv_level] = lv_totalXP;

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libCore_gt_DataXPInitializeLevelXPValues_Init () {

    libCore_gt_DataXPInitializeLevelXPValues = TriggerCreate("libCore_gt_DataXPInitializeLevelXPValues_Func");

}



//--------------------------------------------------------------------------------------------------

// Trigger: Data - XP - Initialize Brawl MetaXP Values

//--------------------------------------------------------------------------------------------------

bool libCore_gt_DataXPInitializeBrawlMetaXPValues_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Actions

    if (!runActions) {

        return true;

    }



    libCore_gv_dataXPBrawlMetaXPValues[0] = 0.0;

    libCore_gv_dataXPBrawlMetaXPValues[1] = 2204.0;

    libCore_gv_dataXPBrawlMetaXPValues[2] = 4127.0;

    libCore_gv_dataXPBrawlMetaXPValues[3] = 8112.0;

    libCore_gv_dataXPBrawlMetaXPValues[4] = 13937.0;

    libCore_gv_dataXPBrawlMetaXPValues[5] = 17539.0;

    libCore_gv_dataXPBrawlMetaXPValues[6] = 22216.0;

    libCore_gv_dataXPBrawlMetaXPValues[7] = 26693.0;

    libCore_gv_dataXPBrawlMetaXPValues[8] = 30074.0;

    libCore_gv_dataXPBrawlMetaXPValues[9] = 33757.0;

    libCore_gv_dataXPBrawlMetaXPValues[10] = 38682.0;

    libCore_gv_dataXPBrawlMetaXPValues[11] = 43518.0;

    libCore_gv_dataXPBrawlMetaXPValues[12] = 47603.0;

    libCore_gv_dataXPBrawlMetaXPValues[13] = 51925.0;

    libCore_gv_dataXPBrawlMetaXPValues[14] = 56471.0;

    libCore_gv_dataXPBrawlMetaXPValues[15] = 61373.0;

    libCore_gv_dataXPBrawlMetaXPValues[16] = 66398.0;

    libCore_gv_dataXPBrawlMetaXPValues[17] = 71301.0;

    libCore_gv_dataXPBrawlMetaXPValues[18] = 76089.0;

    libCore_gv_dataXPBrawlMetaXPValues[19] = 80685.0;

    libCore_gv_dataXPBrawlMetaXPValues[20] = 85255.0;

    libCore_gv_dataXPBrawlMetaXPValues[21] = 90289.0;

    libCore_gv_dataXPBrawlMetaXPValues[22] = 95509.0;

    libCore_gv_dataXPBrawlMetaXPValues[23] = 100422.0;

    libCore_gv_dataXPBrawlMetaXPValues[24] = 105255.0;

    libCore_gv_dataXPBrawlMetaXPValues[25] = 110122.0;

    libCore_gv_dataXPBrawlMetaXPValues[26] = 115032.0;

    libCore_gv_dataXPBrawlMetaXPValues[27] = 120009.0;

    libCore_gv_dataXPBrawlMetaXPValues[28] = 125021.0;

    libCore_gv_dataXPBrawlMetaXPValues[29] = 130125.0;

    libCore_gv_dataXPBrawlMetaXPValues[30] = 135161.0;

    return true;

}



//--------------------------------------------------------------------------------------------------

void libCore_gt_DataXPInitializeBrawlMetaXPValues_Init () {

    libCore_gt_DataXPInitializeBrawlMetaXPValues = TriggerCreate("libCore_gt_DataXPInitializeBrawlMetaXPValues_Func");

}



//--------------------------------------------------------------------------------------------------

// Trigger: Initialize Storm Mod

//--------------------------------------------------------------------------------------------------

bool libCore_gt_InitializeStormMod_Func (bool testConds, bool runActions) {

    // Variable Declarations

    point lv_oldCorePosition;

    unit lv_oldCoreUnit;

    int lv_itPlayer;



    // Automatic Variable Declarations

    const int auto636F45C9_ae = libCore_gv_bALMaxPlayers;

    const int auto636F45C9_ai = 1;



    // Variable Initialization



    // Actions

    if (!runActions) {

        return true;

    }



    libSprt_gv_performanceTestPerformanceTestRunning = GameIsExaminable();

    libCore_gv_dEBUGGameIsOnline = GameIsOnline();

    GameSetSpeedValue(c_gameSpeedNormal);

    GameSetSpeedLocked(true);

    TimerStart(libGame_gv_gobalTimer, c_timerDurationInfinite, false, c_timeGame);

    SetScoreTimer(libGame_gv_gameTimer);

    UnitEventSetNullVariableInvalid(true);

    TriggerExecute(libCore_gt_DEBUGInitializeDataMiningAndDebugOutput, true, false);

    TriggerExecute(libCore_gt_InitializeData, true, false);

    TriggerExecute(libGame_gt_InitializeBanks, true, false);

    TriggerExecute(libGame_gt_InitializePlayers, true, false);

    TriggerExecute(libGame_gt_InitializeGameSystems, true, false);

    TriggerExecute(libUIUI_gt_InitializeUI, true, false);

    TriggerExecute(libMapM_gt_InitializeMapMechanics, true, false);

    TriggerExecute(libGame_gt_InitializeVisibility, true, false);

    libCore_gf_SendEventIncludeModInitialization();

    if ((libCore_gv_dEBUGErrorDuringInitialization == true)) {

        return true;

    }



    if ((libGame_gv_overrideMusicCallback != null)) {

        TriggerExecute(libGame_gv_overrideMusicCallback, true, true);

    }



    TriggerExecute(libCore_gt_InitializeMiscStuff, true, false);

    if ((GameTestConfigType() == 1)) {

        return true;

    }



    if ((GameTestConfigType() == 2)) {

        TriggerExecute(libSprt_gt_PerformanceTestSpawnHeroesForHeroesPerformanceTestMap, true, false);

    }



    if ((GameTestConfigType() == 10)) {

        TriggerExecute(libSprt_gt_AutomatedBuildTest, true, false);

    }



    if ((GameTestConfigType() == 11)) {

        TriggerExecute(libSprt_gt_AISpawningTest, true, false);

    }



    if ((libSprt_gv_performanceTestPerformanceTestRunning == true)) {

        TriggerExecute(libSprt_gt_PerformanceTestRunPerformanceTest, true, false);

    }



    if ((libCore_gv_sYSGameMode == libCore_ge_GameModes_Normal)) {

        libSprt_gf_DataMiningSendStartGameEvents();

    }



    if ((libCore_gv_sYSStartGame == true)) {

        lv_itPlayer = 1;

        for ( ; ( (auto636F45C9_ai >= 0 && lv_itPlayer <= auto636F45C9_ae) || (auto636F45C9_ai < 0 && lv_itPlayer >= auto636F45C9_ae) ) ; lv_itPlayer += auto636F45C9_ai ) {

            CameraUseHeightDisplacement(lv_itPlayer, false);

            libUIUI_gf_UIHeroConsoleShowHideForPlayer(false, lv_itPlayer);

            UISetMode(libCore_gv_playerGroupFromPlayer[lv_itPlayer], c_uiModeFullscreen, c_transitionDurationImmediate);

        }

    }



    libAIAI_gf_HeroAIGeneralPreInit();

    if ((GameTestConfigType() != 2) && (GameTestConfigType() != 3) && (GameTestConfigType() != 4)) {

        libGame_gf_PickingHeroesForPlayers();

    }



    libGame_gf_SendEventGameLoadedUIHook();

    if ((libStEx_gv_tradeShowMovieLink != null)) {

        TransmissionSendForPlayerSelect(PlayerGroupAll(), TransmissionSourceFromMovie(libStEx_gv_tradeShowMovieLink, true), libNtve_gf_FullscreenPortrait(), "", "Talk", null, null, null, 0.0, c_transmissionDurationAdd, true, c_maxPlayers, false);

    }

    else {

        libStEx_gf_PlayMapMechanicTutorial();

    }

    Wait(0.125, c_timeGame);

    if ((libCore_gv_sYSStartGame == true)) {

        TriggerExecute(libGame_gt_StartGame, true, false);

    }



    return true;

}



//--------------------------------------------------------------------------------------------------

void libCore_gt_InitializeStormMod_Init () {

    libCore_gt_InitializeStormMod = TriggerCreate("libCore_gt_InitializeStormMod_Func");

}



//--------------------------------------------------------------------------------------------------

// Trigger: DEBUG - Initialize Data Mining And Debug Output

//--------------------------------------------------------------------------------------------------

bool libCore_gt_DEBUGInitializeDataMiningAndDebugOutput_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Actions

    if (!runActions) {

        return true;

    }



    TriggerDebugSetTypeFile(1, (libCore_gv_debugPathDebugOutput + ".txt"));

    TriggerDebugSetTypeFile(2, (libCore_gv_debugPathScoreValueLog + ".txt"));

    TriggerDebugSetTypeFile(3, (libCore_gv_debugPathEncouragementDataTrackingLog + ".txt"));

    TriggerDebugSetTypeFile(5, (libSprt_gv_performanceTestFPSLogFile + ".txt"));

    TriggerDebugSetTypeFile(6, (libCore_gv_debugPathDeathTimerRenderPrioritiesLog + ".txt"));

    TriggerDebugSetTypeFile(7, (libCore_gv_debugPathIndividualStatTrackerLog + ".txt"));

    TriggerDebugSetTypeFile(8, (libCore_gv_debugPathMVPLog + ".txt"));

    if ((libCore_gv_dEBUGDebuggingEnabled == false)) {

        TriggerDebugOutputEnable(false);

    }



    return true;

}



//--------------------------------------------------------------------------------------------------

void libCore_gt_DEBUGInitializeDataMiningAndDebugOutput_Init () {

    libCore_gt_DEBUGInitializeDataMiningAndDebugOutput = TriggerCreate("libCore_gt_DEBUGInitializeDataMiningAndDebugOutput_Func");

}



//--------------------------------------------------------------------------------------------------

// Trigger: Initialize Data

//--------------------------------------------------------------------------------------------------

bool libCore_gt_InitializeData_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_itPlayer;



    // Automatic Variable Declarations

    const int autoFE901BA2_ae = libCore_gv_bALMaxEnginePlayerCount;

    const int autoFE901BA2_ai = 1;



    // Variable Initialization



    // Actions

    if (!runActions) {

        return true;

    }



    libCore_gv_mAPMapTileset = GameTerrainSet();

    libCore_gv_mAPMapLight = (CatalogFieldValueGet(c_gameCatalogTerrain, libCore_gv_mAPMapTileset, "Lighting", c_playerAny));

    libGame_gf_SetStormMapLighting(libCore_gv_mAPMapLight, PlayerGroupAll(), 0.0);

    CatalogFieldValueSetFixed(c_gameCatalogUnit, "XelNagaWatchTower", "EnergyMax", libCore_gv_cOMPUTER_TeamOrder, (libCore_gv_data_WatchTower_CaptureTime_C * 16.0));

    CatalogFieldValueSetFixed(c_gameCatalogUnit, "XelNagaWatchTower", "EnergyMax", libCore_gv_cOMPUTER_TeamChaos, (libCore_gv_data_WatchTower_CaptureTime_C * 16.0));

    CatalogFieldValueSetFixed(c_gameCatalogUnit, "XelNagaWatchTower", "EnergyMax", libCore_gv_cOMPUTER_Neutral, (libCore_gv_data_WatchTower_CaptureTime_C * 16.0));

    CatalogFieldValueSetFixed(c_gameCatalogUnit, "TownMercCampCaptureBeacon", "EnergyMax", libCore_gv_cOMPUTER_TeamOrder, (libCore_gv_data_WatchTower_CaptureTime_C * 16.0));

    CatalogFieldValueSetFixed(c_gameCatalogUnit, "TownMercCampCaptureBeacon", "EnergyMax", libCore_gv_cOMPUTER_TeamChaos, (libCore_gv_data_WatchTower_CaptureTime_C * 16.0));

    CatalogFieldValueSetFixed(c_gameCatalogUnit, "TownMercCampCaptureBeacon", "EnergyMax", libCore_gv_cOMPUTER_Neutral, (libCore_gv_data_WatchTower_CaptureTime_C * 16.0));

    libCore_gv_cOLORPlayerColor = libCore_gf_GetAllianceColorFromGameUIData("Self", c_playerAny);

    libCore_gv_cOLORAllyColor = libCore_gf_GetAllianceColorFromGameUIData("Ally", c_playerAny);

    libCore_gv_cOLOREnemyColor = libCore_gf_GetAllianceColorFromGameUIData("Hostile", c_playerAny);

    libCore_gv_cOLORNeutralColor = libCore_gf_GetAllianceColorFromGameUIData("Neutral", c_playerAny);

    TechTreeUpgradeAddLevel(libCore_gv_cOMPUTER_Hostile, "CreepColor", 1);

    libCore_gv_cOLORJungleCreepColor = libCore_gf_GetAllianceColorFromGameUIData("Hostile", libCore_gv_cOMPUTER_Hostile);

    lv_itPlayer = 0;

    for ( ; ( (autoFE901BA2_ai >= 0 && lv_itPlayer <= autoFE901BA2_ae) || (autoFE901BA2_ai < 0 && lv_itPlayer >= autoFE901BA2_ae) ) ; lv_itPlayer += autoFE901BA2_ai ) {

        libCore_gv_playerGroupFromPlayer[lv_itPlayer] = PlayerGroupSingle(lv_itPlayer);

    }

    TriggerExecute(libCore_gt_DataHeroesHeroData, true, true);

    TriggerExecute(libMapM_gt_DataJungleCampDefenderData, true, true);

    TriggerExecute(libMapM_gt_DataJungleCampMercData, true, true);

    TriggerExecute(libCore_gt_DataXPInitializeLevelXPValues, true, true);

    TriggerExecute(libCore_gt_DataXPInitializeBrawlMetaXPValues, true, true);

    TriggerExecute(libCore_gt_DataInitializeMountData, true, true);

    TriggerExecute(libCore_gt_DataInitializeSkinData, true, true);

    TriggerExecute(libCore_gt_DataInitializeSprayData, true, true);

    TriggerExecute(libCore_gt_DataInitializeBannerData, true, true);

    TriggerExecute(libCore_gt_DataInitializeAnnouncerPackData, true, true);

    TriggerExecute(libCore_gt_DataAnnouncerVOMapDataFields, true, true);

    TriggerExecute(libCore_gt_DataHeroVOMapDataFields, true, true);

    TriggerExecute(libCore_gt_DataDeathTimes, true, true);

    TriggerExecute(libCore_gt_DataMinionScalingData, true, true);

    TriggerExecute(libCore_gt_DataMinionWaveCompositionData, true, true);

    return true;

}



//--------------------------------------------------------------------------------------------------

void libCore_gt_InitializeData_Init () {

    libCore_gt_InitializeData = TriggerCreate("libCore_gt_InitializeData_Func");

}



//--------------------------------------------------------------------------------------------------

// Trigger: Initialize Misc Stuff

//--------------------------------------------------------------------------------------------------

bool libCore_gt_InitializeMiscStuff_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_i;



    // Automatic Variable Declarations

    // Variable Initialization



    // Actions

    if (!runActions) {

        return true;

    }



    ActorSend(ActorFrom("::Scene"), "SceneHaloSetColor 255,0,0");

    ActorSendAsText(libNtve_gf_MainActorofUnit(libGame_gv_teams[1].lv_core), StringExternal("Param/Value/lib_Core_7B6F68DA"));

    ActorSendAsText(libNtve_gf_MainActorofUnit(libGame_gv_teams[2].lv_core), StringExternal("Param/Value/lib_Core_1BF06750"));

    if ((libCore_gv_sYSGameMode != libCore_ge_GameModes_TutorialVeteran)) {

        libSond_gf_SoundtrackPlayMapIntroSoundtrackForAllPlayers();

    }



    return true;

}



//--------------------------------------------------------------------------------------------------

void libCore_gt_InitializeMiscStuff_Init () {

    libCore_gt_InitializeMiscStuff = TriggerCreate("libCore_gt_InitializeMiscStuff_Func");

}



//--------------------------------------------------------------------------------------------------

// Trigger: _SendTransmissionTick

//--------------------------------------------------------------------------------------------------

bool libCore_gt__SendTransmissionTick_Func (bool testConds, bool runActions) {

    // Automatic Variable Declarations

    // Conditions

    if (testConds) {

        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    TriggerEnable(TriggerGetCurrent(), false);

    while (true) {

        if ((libCore_gv_zS_SendTransmissionCampaignIndex == 0) && (libCore_gv_zS_SendTransmissionCampaignPlayingTick > 0)) {

            libCore_gv_zS_SendTransmissionCampaignPlayingTick -= 1;

        }



        Wait(1.0, c_timeGame);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libCore_gt__SendTransmissionTick_Init () {

    libCore_gt__SendTransmissionTick = TriggerCreate("libCore_gt__SendTransmissionTick_Func");

}



//--------------------------------------------------------------------------------------------------

// Trigger: Auto-Reveal Region Controller

//--------------------------------------------------------------------------------------------------

bool libCore_gt_AutoRevealRegionController_Func (bool testConds, bool runActions) {

    // Variable Declarations

    int lv_i;



    // Automatic Variable Declarations

    int auto1AB864A5_ae;

    const int auto1AB864A5_ai = 1;



    // Variable Initialization



    // Conditions

    if (testConds) {

        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {

            return false;

        }

    }



    // Actions

    if (!runActions) {

        return true;

    }



    TriggerEnable(TriggerGetCurrent(), false);

    while (true) {

        auto1AB864A5_ae = (libCore_gv_autoRevealers.lv_count - 1);

        lv_i = 0;

        for ( ; ( (auto1AB864A5_ai >= 0 && lv_i <= auto1AB864A5_ae) || (auto1AB864A5_ai < 0 && lv_i >= auto1AB864A5_ae) ) ; lv_i += auto1AB864A5_ai ) {

            if ((UnitGroupCount(UnitGroup(null, libCore_gv_autoRevealers.lv_triggeringPlayers[lv_i], libCore_gv_autoRevealers.lv_triggeringRegions[lv_i], UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 1), c_unitCountAlive) > 0)) {

                VisRevealerEnable(libCore_gv_autoRevealers.lv_revealers[lv_i], true);

            }

            else {

                VisRevealerEnable(libCore_gv_autoRevealers.lv_revealers[lv_i], false);

            }

        }

        Wait(1.0, c_timeGame);

    }

    return true;

}



//--------------------------------------------------------------------------------------------------

void libCore_gt_AutoRevealRegionController_Init () {

    libCore_gt_AutoRevealRegionController = TriggerCreate("libCore_gt_AutoRevealRegionController_Func");

}



void libCore_InitTriggers () {

    libCore_gt_IncludeCore_Init();

    libCore_gt_DataAnnouncerVOMapDataFields_Init();

    libCore_gt_DataHeroesHeroData_Init();

    libCore_gt_DataHeroVOMapDataFields_Init();

    libCore_gt_DataInitializeSprayData_Init();

    libCore_gt_DataInitializeBannerData_Init();

    libCore_gt_DataInitializeAnnouncerPackData_Init();

    libCore_gt_DataMinionScalingData_Init();

    libCore_gt_DataMinionWaveCompositionData_Init();

    libCore_gt_DataInitializeMountData_Init();

    libCore_gt_DataDeathTimes_Init();

    libCore_gt_BrettTimersSetVariables_Init();

    libCore_gt_BrettTimersCheckDeathTimerMod_Init();

    libCore_gt_BrettTimersTakedownParticipation_Init();

    libCore_gt_DataInitializeSkinData_Init();

    libCore_gt_DataEnableGranularBountyXPMathDisplay_Init();

    libCore_gt_DataXPInitializeLevelXPValues_Init();

    libCore_gt_DataXPInitializeBrawlMetaXPValues_Init();

    libCore_gt_InitializeStormMod_Init();

    libCore_gt_DEBUGInitializeDataMiningAndDebugOutput_Init();

    libCore_gt_InitializeData_Init();

    libCore_gt_InitializeMiscStuff_Init();

    libCore_gt__SendTransmissionTick_Init();

    libCore_gt_AutoRevealRegionController_Init();

}



//--------------------------------------------------------------------------------------------------

// Library Initialization

//--------------------------------------------------------------------------------------------------

bool libCore_InitLib_completed = false;



void libCore_InitLib () {

    if (libCore_InitLib_completed) {

        return;

    }



    libCore_InitLib_completed = true;



    libCore_InitLibraries();

    libCore_InitVariables();

    libCore_InitTriggers();

}



include "TriggerLibs/GameLib"

include "TriggerLibs/MapMechanicsLib"

include "TriggerLibs/AILib"

include "TriggerLibs/UILib"

include "TriggerLibs/StartingExperienceLib"

include "TriggerLibs/SoundLib"

include "TriggerLibs/GameDataHelperLib"

include "TriggerLibs/SupportLib"