//==================================================================================================
// 
// Generated Map Script
// 
// Name:   Heroes of the Storm Tutorial
// 
//==================================================================================================
include "TriggerLibs/NativeLib"
include "TriggerLibs/HeroesLib"
include "TriggerLibs/GameLib"
include "TriggerLibs/MapMechanicsLib"
include "TriggerLibs/AILib"
include "TriggerLibs/UILib"
include "TriggerLibs/StartingExperienceLib"
include "TriggerLibs/SoundLib"
include "TriggerLibs/GameDataHelperLib"
include "TriggerLibs/SupportLib"

//--------------------------------------------------------------------------------------------------
// Library Initialization
//--------------------------------------------------------------------------------------------------
void InitLibs () {
    libNtve_InitLib();
    libCore_InitLib();
    libGame_InitLib();
    libMapM_InitLib();
    libAIAI_InitLib();
    libUIUI_InitLib();
    libStEx_InitLib();
    libSond_InitLib();
    libGDHL_InitLib();
    libSprt_InitLib();
}

//--------------------------------------------------------------------------------------------------
// Constants
//--------------------------------------------------------------------------------------------------
const int gv_pLAYER_01_USER = 1;
const int gv_pLAYER_02_UTHER = 2;
const int gv_pLAYER_06_DIABLO = 6;
const int gv_pLAYER_07_STITCHES = 7;
const int gv_pLAYER_11_ORDER = 11;
const int gv_pLAYER_12_CHAOS = 12;

//--------------------------------------------------------------------------------------------------
// Global Variables
//--------------------------------------------------------------------------------------------------
unit gv_hERO_Raynor;
unit gv_hERO_Instructor;
unit gv_hERO_Diablo;
unit gv_hERO_Stitch;
int gv_leftRightClickScheme;
unit gv__1A_Beacon;
bool gv__1A_BeaconOrderIssued;
int gv__1A_BeaconMoveButtonCurrent;
int gv__1A_BeaconMoveButtonOther;
bool gv__1A_BeaconReached;
bool gv__1A_BeaconObjectiveCreated;
sound gv__1A_BeaconSound;
unit gv__1B_AttackSkeleton1;
bool gv__1B_AttackSkeleton1Attacked;
bool gv__1B_AttackSkeleton1Killed;
bool gv__1B_AttackSkeleton1ObjectiveCreated;
unitgroup gv__1B_AttackMoreSkeletonsA;
unitgroup gv__1B_AttackMoreSkeletonsB;
unitgroup gv__1B_AttackMoreSkeletonsC;
unitgroup gv__1B_AttackMoreSkeletonsAll;
int gv__1B_AttackMoreSkeletonsCount;
int gv__1B_AttackMoreSkeletonsPingA;
int gv__1B_AttackMoreSkeletonsPingB;
int gv__1B_AttackMoreSkeletonsPingC;
bool gv__1B_AMoveEnemiesAttacked;
actor gv__1B_AMoveReticle;
int gv__1B_AMoveTextTag;
unit gv__1B_Globe;
unit gv__1B_GlobeDroppingUnit1;
unit gv__1B_GlobeDroppingUnit2;
bool gv__1B_GlobeExplained;
actor gv__1B_GlobeReticle;
int gv__1B_GlobeTextTag;
bool gv__1C_PenRoundHit;
actor gv__1C_PenRoundReticle;
int gv__1C_PenRoundTextTag;
bool gv__1C_PenRoundCasted;
int[11] gv__1C_SkeletonPings;
unitgroup[11] gv__1C_SkeletonGroups;
unitgroup gv__1C_InspireAllies;
bool gv__1C_InspireUsed;
bool gv__1C_InspireUsedMore;
bool gv__1C_InspireUsedMoreMore;
unitgroup gv__1C_Zombies;
unitgroup gv__1C_Zombies1;
unitgroup gv__1C_Zombies2;
unitgroup gv__1C_Zombies3;
unitgroup gv__1C_Zombies4;
unitgroup gv__1C_Zombies5;
unitgroup gv__1C_Zombies6;
int gv__1C_ZombieCountKilled;
int gv__1C_ZombieCountTotal;
bool gv__1D_CameraInitroLockButtonClicked;
bool gv__1D_CameraLockButtonClicked;
bool gv__1D_CameraMoved;
bool gv__1D_DiabloFound;
revealer gv__1D_DiabloRevealer;
int gv__1D_DiabloPing;
unitgroup gv__1D_DiabloFightMinion;
bool gv__1D_SpacebarPressed;
bool gv__1D_DiabloFightBegan;
int gv__1D_MoveCameraTransmission;
bool[5] gv__1D_CameraArrowPointing;
bool gv__1D_PenetratingRoundUsed;
bool gv__1D_PenetratingRoundTutorialDone;
bool gv__2A_TeleportStarted;
bool gv_minion_SpawnPaused;
int gv__2_HintTypeLast;
int gv__2_HintType;
fixed gv__2_HintOnDuration;
int gv__2_HintPlaying;
int gv__2B_PingFrontLine;
unit[3] gv__2B_Towers;
int gv__2B_TowerAlives;
point gv__2B_TowerEscape;
actor gv__2B_TowersEscapeActor;
int gv__2B_TowersEscapeTextTag;
bool gv__2B_TowersEscapeOrderIssued;
bool gv__2B_TowersEscapeEscaped;
unitgroup gv__2B_TowersEscapeUnitsPaused;
actor gv__2C_CoreReticle;
bool gv__2C_MountUsed;
point gv__2C_FortEscape;
actor gv__2C_FortEscapeActor;
int gv__2C_FortEscapeTextTag;
bool gv__2C_FortEscapeOrderIssued;
bool gv__2C_FortEscapeEscaped;
unitgroup gv__2C_FortEscapeUnitsPaused;
point gv__2C_PalaceEscape;
actor gv__2C_PalaceEscapeActor;
int gv__2C_PalaceEscapeTextTag;
bool gv__2C_PalaceEscapeOrderIssued;
bool gv__2C_PalaceEscapeEscaped;
unitgroup gv__2C_PalaceEscapeUnitsPaused;
timer gv__2C_UseAbilityTimer;
int gv_objectiveMoveToBeacon;
int gv_objectiveKillTheUndead;
int gv_objectiveKillMoreUndead;
int gv_objectiveKillZombies;
int gv_objectiveFindDiablo;
int gv_objectiveKillDiablo;
int gv_objectiveBacktoBase;
int gv_objectiveMountUp;
int gv_objectiveKillEnemyTowers;
int gv_objectiveKillEnemyFort;
int gv_objectiveKillEnemyPalace;
int gv_objectiveMovetoFrontLine;
unitgroup gv_cinematicHiddenUnits;
unitgroup gv_cinematicPausedUnits;
unitgroup gv_cinematicTempUnits;
bool gv_cinematicCompleted;
actor gv_intro_TPEffect;
int gv_intro_CutSceneDialog;
int gv_intro_CutSceneWarpIn;
int gv_intro_CutSceneStormGate;
unit gv_midSkeletonAttack;
actor gv_midSkeletonAttackTPRaynor;
actor gv_midSkeletonAttackTPUther;
revealer gv_midSkeletonAttackRevealer;
unit gv_midGarrision_Uther;
actor gv_midGarrision_RaynorTeleportEffect;
unitgroup gv_midGarrision_OrdersWave;
unitgroup gv_midGarrision_ChaosWave;
unit gv_midDeath_Stitches;
unit gv_midDeath_Diablo;
unit gv_midDeath_Raynor;
unit gv_midDeath_TownGate;
unitgroup gv_midDeath_MinionsLeft;
unitgroup gv_midDeath_MinionsRight;
int gv_victory_CutScene;

void InitGlobals () {
    int init_i;

    gv__1B_AttackMoreSkeletonsA = UnitGroupEmpty();
    gv__1B_AttackMoreSkeletonsB = UnitGroupEmpty();
    gv__1B_AttackMoreSkeletonsC = UnitGroupEmpty();
    gv__1B_AttackMoreSkeletonsAll = UnitGroupEmpty();
    gv__1B_AttackMoreSkeletonsPingA = c_invalidPingId;
    gv__1B_AttackMoreSkeletonsPingB = c_invalidPingId;
    gv__1B_AttackMoreSkeletonsPingC = c_invalidPingId;
    gv__1B_AMoveTextTag = c_textTagNone;
    gv__1B_GlobeTextTag = c_textTagNone;
    gv__1C_PenRoundTextTag = c_textTagNone;
    for (init_i = 0; init_i <= 10; init_i += 1) {
        gv__1C_SkeletonPings[init_i] = c_invalidPingId;
    }
    for (init_i = 0; init_i <= 10; init_i += 1) {
        gv__1C_SkeletonGroups[init_i] = UnitGroupEmpty();
    }
    gv__1C_InspireAllies = UnitGroupEmpty();
    gv__1C_Zombies = UnitGroupEmpty();
    gv__1C_Zombies1 = UnitGroupEmpty();
    gv__1C_Zombies2 = UnitGroupEmpty();
    gv__1C_Zombies3 = UnitGroupEmpty();
    gv__1C_Zombies4 = UnitGroupEmpty();
    gv__1C_Zombies5 = UnitGroupEmpty();
    gv__1C_Zombies6 = UnitGroupEmpty();
    gv__1D_DiabloPing = c_invalidPingId;
    gv__1D_DiabloFightMinion = UnitGroupEmpty();
    gv__1D_MoveCameraTransmission = c_invalidTransmissionId;
    gv__2B_PingFrontLine = c_invalidPingId;
    gv__2B_TowerAlives = 2;
    gv__2B_TowersEscapeTextTag = c_textTagNone;
    gv__2B_TowersEscapeUnitsPaused = UnitGroupEmpty();
    gv__2C_FortEscapeTextTag = c_textTagNone;
    gv__2C_FortEscapeUnitsPaused = UnitGroupEmpty();
    gv__2C_PalaceEscapeTextTag = c_textTagNone;
    gv__2C_PalaceEscapeUnitsPaused = UnitGroupEmpty();
    gv__2C_UseAbilityTimer = TimerCreate();
    gv_objectiveMoveToBeacon = c_invalidObjectiveId;
    gv_objectiveKillTheUndead = c_invalidObjectiveId;
    gv_objectiveKillMoreUndead = c_invalidObjectiveId;
    gv_objectiveKillZombies = c_invalidObjectiveId;
    gv_objectiveFindDiablo = c_invalidObjectiveId;
    gv_objectiveKillDiablo = c_invalidObjectiveId;
    gv_objectiveBacktoBase = c_invalidObjectiveId;
    gv_objectiveMountUp = c_invalidObjectiveId;
    gv_objectiveKillEnemyTowers = c_invalidObjectiveId;
    gv_objectiveKillEnemyFort = c_invalidObjectiveId;
    gv_objectiveKillEnemyPalace = c_invalidObjectiveId;
    gv_objectiveMovetoFrontLine = c_invalidObjectiveId;
    gv_cinematicHiddenUnits = UnitGroupEmpty();
    gv_cinematicPausedUnits = UnitGroupEmpty();
    gv_cinematicTempUnits = UnitGroupEmpty();
    gv_intro_CutSceneDialog = c_invalidDialogId;
    gv_intro_CutSceneWarpIn = c_cutsceneNone;
    gv_intro_CutSceneStormGate = c_cutsceneNone;
    gv_midGarrision_OrdersWave = UnitGroupEmpty();
    gv_midGarrision_ChaosWave = UnitGroupEmpty();
    gv_midDeath_MinionsLeft = UnitGroupEmpty();
    gv_midDeath_MinionsRight = UnitGroupEmpty();
    gv_victory_CutScene = c_cutsceneNone;
}

//--------------------------------------------------------------------------------------------------
// Global Function Declarations
//--------------------------------------------------------------------------------------------------
void gf_RestoreHero ();
region gf_RegionWithOffset (region lp_area, fixed lp_leftOffset, fixed lp_rightOffset, fixed lp_topOffset, fixed lp_bottomOffset);
void gf_SetPlayableWithLooseCameraBounds (region lp_area);
void gf_CreateTeleportInModel (point lp_position);
void gf_SpawnRaynor (point lp_pos, bool lp_spawnEffect);
void gf__1BSpawnGlobeQ (point lp_location);
void gf__1CPenRoundPrepareSkeleton (unit lp_skeleton);
void gf__1CPenRoundPrepareSkeletonPos (unit lp_skeleton, unit lp_frontSkeleton, fixed lp_distantce, fixed lp_angle);
int gf__2HintTypeLevel (int lp_msgType);
void gf__2DisplayHintMessage (int lp_type);
point gf__2BTowerSuggestedEspacePosition (point lp_towerPos1, point lp_towerPos2, fixed lp_attackRange, point lp_heroPos);
bool gf__2BTowerSuggestedEspacePositionGood (point lp_orderPos);
point gf__2CFortSuggestedEspacePosition (point lp_fortPos, fixed lp_attackRange, point lp_heroPos);
point gf__2CPalaceSuggestedEspacePosition (point lp_fortPos, fixed lp_attackRange, point lp_heroPos);
void gf_MidGarrisonCinematicSendChaosWave (unitgroup lp_wave);

//--------------------------------------------------------------------------------------------------
// Trigger Variables
//--------------------------------------------------------------------------------------------------
trigger gt_Initialization;
trigger gt_Init01Data;
trigger gt_Init02Unit;
trigger gt_Init03UI;
trigger gt_Init04Environment;
trigger gt_Init05Ally;
trigger gt_StormInitializeMap;
trigger gt_StormHookupGlobalVariables;
trigger gt_StormHookupLaneData;
trigger gt_StormHookupJungleCreepData;
trigger gt_StormHookupTownData;
trigger gt_StormStartGame;
trigger gt_DebugStage2Abilities;
trigger gt_DebugStage3Camera;
trigger gt_DebugStage4DiabloFight;
trigger gt_DebugStage5Town;
trigger gt_DebugStage6Victory;
trigger gt_DebugTemp;
trigger gt_AddReferenceCardMove;
trigger gt_AddReferenceCardAttack;
trigger gt_AddReferenceCardPenetratingRound;
trigger gt_AddReferenceCardInspire;
trigger gt_AddReferenceCardCamera;
trigger gt__1_RaynorWontDie;
trigger gt__1AStartGameQ;
trigger gt__1ABeaconHighlight;
trigger gt__1ABeaconUnhighlight;
trigger gt__1AMoveOrderIssued;
trigger gt__1AMoveButtonSelected;
trigger gt__1ABeaconReached;
trigger gt__1ABeaconSound;
trigger gt__1BAttackSkeleton1Q;
trigger gt__1BAttackSkeleton1Highlight;
trigger gt__1BAttackSkeleton1Unhighlight;
trigger gt__1BAttackSkeleton1Attacked;
trigger gt__1BAttackSkeleton1Dies;
trigger gt__1BAttackMoreSkeletonsQ;
trigger gt__1BMinimapPulse;
trigger gt__1BAttackMoreSkeletonsAAttacked;
trigger gt__1BAttackMoreSkeletonsDied;
trigger gt__1BAttackMoreSkeletonsCAttacked;
trigger gt__1BAMoveEnemiesApproachedQ;
trigger gt__1BAMoveAttackOrderIssued;
trigger gt__1BAMoveHighlight;
trigger gt__1BAMoveEnemiesAttacked;
trigger gt__1BAttackSkeletonsWhatAreTheseMonstersQ;
trigger gt__1BGlobeRun1;
trigger gt__1BGlobeRun2;
trigger gt__1BDropGlobe1;
trigger gt__1BDropGlobe2;
trigger gt__1BGlobePickedUpQ;
trigger gt__1CPenRoundPrep;
trigger gt__1CPenRoundQ;
trigger gt__1CPenRoundHitQ;
trigger gt__1CPenRoundTargetingModeOn;
trigger gt__1CPenRoundTargetingModeOff;
trigger gt__1CPenRoundCasted;
trigger gt__1CPenRoundMissedQ;
trigger gt__1CPenRoundAgainQ;
trigger gt__1CPenRoundAgainRaynorStop;
trigger gt__1CPenRoundAgainHitQ;
trigger gt__1CPenRoundAgainAgainQ;
trigger gt__1CPenRoundAgainAgainRaynorStop;
trigger gt__1CPenRoundAgainAgainHitQ;
trigger gt__1CZombiesInspireQ;
trigger gt__1CInspireQ;
trigger gt__1CInspireUseful;
trigger gt__1CInspireUsedQ;
trigger gt__1CInspireUseMoreQ;
trigger gt__1CInspireUsedMore;
trigger gt__1CInspireUseMoreMoreQ;
trigger gt__1CInspireUsedMoreMore;
trigger gt__1CZombieDies;
trigger gt__1CZombieAllyAttack4;
trigger gt__1CZombieAllyAttack5;
trigger gt__1CZombieAttacked;
trigger gt__1CZombies2Approached;
trigger gt__1CZombies3Approached;
trigger gt__1CZombies4Approached;
trigger gt__1CZombies5Approached;
trigger gt__1CZombies6Approached;
trigger gt__1CZombies3DropGlobe;
trigger gt__1DCameraLockQ;
trigger gt__1DCameraUnlocked;
trigger gt__1DCameraMoved;
trigger gt__1DCameraSpacebarPressed;
trigger gt__1DCameraArrowLogic;
trigger gt__1DCameraLocationLogic;
trigger gt__1DDiabloFightQ;
trigger gt__1DDiabloPing;
trigger gt__1DRaynorEnterDiabloBanterQ;
trigger gt__1DRaynorEnterDiabloRegionChange;
trigger gt__1DRaynorEnterDiabloArena;
trigger gt__1DDiabloFightBegin;
trigger gt__1DDiabloPenetratingRoundUsed;
trigger gt__1DDiabloAI;
trigger gt__1DDiabloPenetratingRoundTutorialRaynorDamaged;
trigger gt__1DDiabloPenetratingRoundTutorialQ;
trigger gt__1DDiabloPenetratingRoundTutorialUsed;
trigger gt__1DDiabloWon;
trigger gt__2ATeleportBaseQ;
trigger gt__2ATeleportBaseStarted;
trigger gt__2ATeleportBaseCanceled;
trigger gt__2ATeleportBaseCompleted;
trigger gt_MinionSpawnCycleTutorialOrder;
trigger gt_MinionSpawnCycleTutorialChaos;
trigger gt_MinionScaling;
trigger gt__2RemoveEnemyGlobe;
trigger gt__2BTownStart;
trigger gt__2BStartMinionSystem;
trigger gt__2BTowerDanger;
trigger gt__2BInDangerStrategyBeforeUtherJoins;
trigger gt__2BMinionStrategyQ;
trigger gt__2BTowerStrategyQ;
trigger gt__2BTowerDiesQ;
trigger gt__2BTowerDamageQ;
trigger gt__2BTowerTakesDamage;
trigger gt__2BTowerDamageEscape;
trigger gt__2BTowerDamageEscapeReticleEffect;
trigger gt__2BTowerDamageEscapeTransmissionQ;
trigger gt__2BTowerDamageEscapeWrong;
trigger gt__2BTowerDamageEscapeMoved;
trigger gt__2BTowerDamageEscapeReached;
trigger gt__2BTowerDamageEscapeMore;
trigger gt__2CFinalBattleStart;
trigger gt__2CCustomizedHeroDeathTimer;
trigger gt__2CMountTutorialQ;
trigger gt__2CMountAway;
trigger gt__2CMountUsed;
trigger gt__2CMountNoLongerNeeded;
trigger gt__2CMountReminder;
trigger gt__2CMountReminderUsed;
trigger gt__2CMountReminderNoLongerNeeded;
trigger gt__2CFortApproached;
trigger gt__2CFortDestoryedQ;
trigger gt__2CFortDamage;
trigger gt__2CFortDamageEscape;
trigger gt__2CFortDamageEscapeReticleEffect;
trigger gt__2CFortDamageEscapeTransmissionQ;
trigger gt__2CFortDamageEscapeWrong;
trigger gt__2CFortDamageEscapeMoved;
trigger gt__2CFortDamageEscapeReached;
trigger gt__2CFortTakesDamage;
trigger gt__2CUtherJoins;
trigger gt__2CPalaceDamage;
trigger gt__2CPalaceDamageEscape;
trigger gt__2CPalaceDamageEscapeReticleEffect;
trigger gt__2CPalaceDamageEscapeTransmissionQ;
trigger gt__2CPalaceDamageEscapeWrong;
trigger gt__2CPalaceDamageEscapeMoved;
trigger gt__2CPalaceDamageEscapeReached;
trigger gt__2CPalaceTakesDamage;
trigger gt__2CPalaceDied;
trigger gt__2CTakingDamageFromMinion;
trigger gt__2CTakingDamageFromMinionTransmission;
trigger gt__2CUseAbilitiesStartTimer;
trigger gt__2CUseAbilitiesTimerExpires;
trigger gt__2CUseAbilitiesUsed;
trigger gt_ObjectiveMoveToBeaconCreate;
trigger gt_ObjectiveMoveToBeaconComplete;
trigger gt_ObjectiveKilltheUndeadCreate;
trigger gt_ObjectiveKilltheUndeadComplete;
trigger gt_ObjectiveKillMoreUndeadCreate;
trigger gt_ObjectiveKillMoreUndeadUpdate;
trigger gt_ObjectiveKillMoreUndeadComplete;
trigger gt_ObjectiveKillZombiesCreate;
trigger gt_ObjectiveKillZombiesUpdate;
trigger gt_ObjectiveKillZombiesComplete;
trigger gt_ObjectiveFindDiabloCreate;
trigger gt_ObjectiveFindDiabloComplete;
trigger gt_ObjectiveKillDiabloCreate;
trigger gt_ObjectiveKillDiabloComplete;
trigger gt_ObjectiveBacktoBaseCreate;
trigger gt_ObjectiveBacktoBaseComplete;
trigger gt_ObjectiveMountUpCreate;
trigger gt_ObjectiveMountUpComplete;
trigger gt_ObjectiveKillEnemyTowersCreate;
trigger gt_ObjectiveKillEnemyTowersUpdate;
trigger gt_ObjectiveKillEnemyTowersComplete;
trigger gt_ObjectiveKillEnemyFortCreate;
trigger gt_ObjectiveKillEnemyFortComplete;
trigger gt_ObjectiveKillEnemyPalaceCreate;
trigger gt_ObjectiveKillEnemyPalaceComplete;
trigger gt_ObjectiveMovetoFrontLineCreate;
trigger gt_ObjectiveMovetoFrontLineComplete;
trigger gt_IntroQ;
trigger gt_IntroSetup;
trigger gt_IntroCinematic;
trigger gt_IntroCinematicEnd;
trigger gt_IntroCleanup;
trigger gt_IntroReticleEffect;
trigger gt_MidSkeletonAttackQ;
trigger gt_MidSkeletonAttackSetup;
trigger gt_MidSkeletonAttackCinematic;
trigger gt_MidSkeletonAttackCinematicEnd;
trigger gt_MidSkeletonAttackCleanup;
trigger gt_MidSkeletonAttackUtherMove;
trigger gt_MidAbilityQ;
trigger gt_MidAbilitySetup;
trigger gt_MidAbilityCinematic;
trigger gt_MidAbilityCinematicEnd;
trigger gt_MidAbilityCleanup;
trigger gt_MidGarrisonQ;
trigger gt_MidGarrisonSetup;
trigger gt_MidGarrisonCinematic;
trigger gt_MidGarrisonCinematicEnd;
trigger gt_MidGarrisonCleanup;
trigger gt_MidGarrisonCinematicSpawnChaosWave;
trigger gt_MidGarrisonCinematicSpawnOrderWave;
trigger gt_MidGarrisonCinematicMinionCamera;
trigger gt_MidTowerDangerQ;
trigger gt_MidTowerDangerSetup;
trigger gt_MidTowerDangerCinematic;
trigger gt_MidTowerDangerCinematicEnd;
trigger gt_MidTowerDangerCleanup;
trigger gt_MidDeathQ;
trigger gt_MidDeathSetup;
trigger gt_MidDeathCinematic;
trigger gt_MidDeathCinematicEnd;
trigger gt_MidDeathCleanup;
trigger gt_VictoryQ;
trigger gt_VictorySetup;
trigger gt_VictoryCinematic;
trigger gt_VictoryCinematicEnd;
trigger gt_VictoryCleanup;

//--------------------------------------------------------------------------------------------------
// Custom Script: Tutorial Tactical Hero AI
//--------------------------------------------------------------------------------------------------
//include "StormTactical.galaxy"

//--------------------------------------------------------------------------------------------------
// Custom Script Initialization
//--------------------------------------------------------------------------------------------------
void InitCustomScript () {
}

//--------------------------------------------------------------------------------------------------
// Global Functions
//--------------------------------------------------------------------------------------------------
void gf_RestoreHero () {
    // Implementation
    libStEx_gf_RestoreUnit(gv_hERO_Raynor);
}

region gf_RegionWithOffset (region lp_area, fixed lp_leftOffset, fixed lp_rightOffset, fixed lp_topOffset, fixed lp_bottomOffset) {
    // Variable Declarations
    fixed lv_x1;
    fixed lv_x2;
    fixed lv_y1;
    fixed lv_y2;
    region lv_result;

    // Variable Initialization

    // Implementation
    lv_x1 = PointGetX(RegionGetBoundsMin(lp_area));
    lv_x2 = PointGetX(RegionGetBoundsMax(lp_area));
    lv_y1 = PointGetY(RegionGetBoundsMin(lp_area));
    lv_y2 = PointGetY(RegionGetBoundsMax(lp_area));
    lv_result = RegionRect((lv_x1 + lp_leftOffset), (lv_y1 + lp_bottomOffset), (lv_x2 + lp_rightOffset), (lv_y2 + lp_topOffset));
    return lv_result;
}

void gf_SetPlayableWithLooseCameraBounds (region lp_area) {
    // Implementation
    RegionPlayableMapSet(lp_area);
    libGame_gf_SetCameraBoundStormForPlayer(gv_pLAYER_01_USER, gf_RegionWithOffset(lp_area, -8.0, 8.0, 8.0, -8.0));
}

trigger auto_gf_CreateTeleportInModel_Trigger = null;
point auto_gf_CreateTeleportInModel_lp_position;

void gf_CreateTeleportInModel (point lp_position) {
    auto_gf_CreateTeleportInModel_lp_position = lp_position;

    if (auto_gf_CreateTeleportInModel_Trigger == null) {
        auto_gf_CreateTeleportInModel_Trigger = TriggerCreate("auto_gf_CreateTeleportInModel_TriggerFunc");
    }

    TriggerExecute(auto_gf_CreateTeleportInModel_Trigger, false, false);
}

bool auto_gf_CreateTeleportInModel_TriggerFunc (bool testConds, bool runActions) {
    point lp_position = auto_gf_CreateTeleportInModel_lp_position;

    // Implementation
    SoundPlay(SoundLink("Gen_Hero_Respawn", -1), PlayerGroupAll(), 100.0, 0.0);
    libNtve_gf_CreateModelAtPoint("Storm_UI_HeroSelection_LightningBeam", lp_position);
    Wait(2.0, c_timeGame);
    libNtve_gf_KillModel(libNtve_gf_ActorLastCreated());
    return true;
}

trigger auto_gf_SpawnRaynor_Trigger = null;
point auto_gf_SpawnRaynor_lp_pos;
bool auto_gf_SpawnRaynor_lp_spawnEffect;

void gf_SpawnRaynor (point lp_pos, bool lp_spawnEffect) {
    auto_gf_SpawnRaynor_lp_pos = lp_pos;
    auto_gf_SpawnRaynor_lp_spawnEffect = lp_spawnEffect;

    if (auto_gf_SpawnRaynor_Trigger == null) {
        auto_gf_SpawnRaynor_Trigger = TriggerCreate("auto_gf_SpawnRaynor_TriggerFunc");
    }

    TriggerExecute(auto_gf_SpawnRaynor_Trigger, false, false);
}

bool auto_gf_SpawnRaynor_TriggerFunc (bool testConds, bool runActions) {
    point lp_pos = auto_gf_SpawnRaynor_lp_pos;
    bool lp_spawnEffect = auto_gf_SpawnRaynor_lp_spawnEffect;

    // Implementation
    if ((lp_spawnEffect == true)) {
        gf_CreateTeleportInModel(lp_pos);
    }
    else {
    }
    libGame_gf_SpawnHero(gv_pLAYER_01_USER, libStEx_gf_HeroIndex("Raynor"), lp_pos);
    gv_hERO_Raynor = libGame_gv_players[gv_pLAYER_01_USER].lv_heroUnit;
    UnitSetPropertyFixed(gv_hERO_Raynor, c_unitPropLifeMax, 1000.0);
    UnitSetPropertyFixed(gv_hERO_Raynor, c_unitPropLife, 1000.0);
    CameraFollowUnitGroup(gv_pLAYER_01_USER, libNtve_gf_ConvertUnitToUnitGroup(gv_hERO_Raynor), true, false);
    return true;
}

void gf__1BSpawnGlobeQ (point lp_location) {
    // Implementation
    UnitCreate(1, "RegenGlobe", c_unitCreateIgnorePlacement, gv_pLAYER_11_ORDER, lp_location, 270.0);
    UnitBehaviorRemove(UnitLastCreated(), "RegenGlobeTimedLife", 1);
    if ((gv__1B_Globe == null)) {
        gv__1B_Globe = UnitLastCreated();
        TriggerEnable(gt__1BGlobePickedUpQ, true);
        Wait(0.5, c_timeReal);
        TriggerQueueEnter();
        if ((UnitIsAlive(gv__1B_Globe) == false)) {
            return ;
        }
        else {
        }
        if ((gv__1B_GlobeExplained == false)) {
            gv__1B_GlobeExplained = true;
            libCore_gf_CreateReticleEffectAndTextTagAtPoint(0, 2, StringExternal("Param/Value/25139D35"), PointWithOffset(UnitGetPosition(gv__1B_Globe), 0.0, 0.5));
            gv__1B_GlobeReticle = libNtve_gf_ActorLastCreated();
            gv__1B_GlobeTextTag = TextTagLastCreated();
            TextTagSetFogVisibility(gv__1B_GlobeTextTag, c_visTypeMask);
            libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
            libCore_gf_SendTransmissionCampaign(gv_hERO_Raynor, "TutorialVO|Line00334", c_transmissionDurationAdd, 0.0, true, 2, 0);
            libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00227", c_transmissionDurationAdd, 0.0, true, 2, 0);
            libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
        }
        else {
        }
        TriggerQueueExit();
    }
    else {
    }
}

trigger auto_gf__1CPenRoundPrepareSkeleton_Trigger = null;
unit auto_gf__1CPenRoundPrepareSkeleton_lp_skeleton;

void gf__1CPenRoundPrepareSkeleton (unit lp_skeleton) {
    auto_gf__1CPenRoundPrepareSkeleton_lp_skeleton = lp_skeleton;

    if (auto_gf__1CPenRoundPrepareSkeleton_Trigger == null) {
        auto_gf__1CPenRoundPrepareSkeleton_Trigger = TriggerCreate("auto_gf__1CPenRoundPrepareSkeleton_TriggerFunc");
    }

    TriggerExecute(auto_gf__1CPenRoundPrepareSkeleton_Trigger, false, false);
}

bool auto_gf__1CPenRoundPrepareSkeleton_TriggerFunc (bool testConds, bool runActions) {
    unit lp_skeleton = auto_gf__1CPenRoundPrepareSkeleton_lp_skeleton;

    // Implementation
    libNtve_gf_PlayAnimation(libNtve_gf_MainActorofUnit(lp_skeleton), c_animNameDefault, "Birth", c_animFlagNonLooping, c_animTimeDefault);
    UnitIssueOrder(lp_skeleton, Order(AbilityCommand("move", 2)), c_orderQueueReplace);
    libNtve_gf_ShowHideUnit(lp_skeleton, true);
    libNtve_gf_PauseUnit(lp_skeleton, false);
    return true;
}

trigger auto_gf__1CPenRoundPrepareSkeletonPos_Trigger = null;
unit auto_gf__1CPenRoundPrepareSkeletonPos_lp_skeleton;
unit auto_gf__1CPenRoundPrepareSkeletonPos_lp_frontSkeleton;
fixed auto_gf__1CPenRoundPrepareSkeletonPos_lp_distantce;
fixed auto_gf__1CPenRoundPrepareSkeletonPos_lp_angle;

void gf__1CPenRoundPrepareSkeletonPos (unit lp_skeleton, unit lp_frontSkeleton, fixed lp_distantce, fixed lp_angle) {
    auto_gf__1CPenRoundPrepareSkeletonPos_lp_skeleton = lp_skeleton;
    auto_gf__1CPenRoundPrepareSkeletonPos_lp_frontSkeleton = lp_frontSkeleton;
    auto_gf__1CPenRoundPrepareSkeletonPos_lp_distantce = lp_distantce;
    auto_gf__1CPenRoundPrepareSkeletonPos_lp_angle = lp_angle;

    if (auto_gf__1CPenRoundPrepareSkeletonPos_Trigger == null) {
        auto_gf__1CPenRoundPrepareSkeletonPos_Trigger = TriggerCreate("auto_gf__1CPenRoundPrepareSkeletonPos_TriggerFunc");
    }

    TriggerExecute(auto_gf__1CPenRoundPrepareSkeletonPos_Trigger, false, false);
}

bool auto_gf__1CPenRoundPrepareSkeletonPos_TriggerFunc (bool testConds, bool runActions) {
    unit lp_skeleton = auto_gf__1CPenRoundPrepareSkeletonPos_lp_skeleton;
    unit lp_frontSkeleton = auto_gf__1CPenRoundPrepareSkeletonPos_lp_frontSkeleton;
    fixed lp_distantce = auto_gf__1CPenRoundPrepareSkeletonPos_lp_distantce;
    fixed lp_angle = auto_gf__1CPenRoundPrepareSkeletonPos_lp_angle;

    // Implementation
    UnitSetPosition(lp_skeleton, PointWithOffsetPolar(UnitGetPosition(lp_frontSkeleton), lp_distantce, (AngleBetweenPoints(UnitGetPosition(gv_hERO_Raynor), UnitGetPosition(lp_frontSkeleton)) + lp_angle)), false);
    gf__1CPenRoundPrepareSkeleton(lp_skeleton);
    return true;
}

int gf__2HintTypeLevel (int lp_msgType) {
    int auto634A8302_val;

    // Implementation
    auto634A8302_val = lp_msgType;
    if (auto634A8302_val == 2) {
        return 2;
    }
    else if (auto634A8302_val == 3) {
        return 2;
    }
    else if (auto634A8302_val == 4) {
        return 2;
    }
    else if (auto634A8302_val == 1) {
        return 1;
    }
    else {
        return -1;
    }
}

trigger auto_gf__2DisplayHintMessage_Trigger = null;
int auto_gf__2DisplayHintMessage_lp_type;

void gf__2DisplayHintMessage (int lp_type) {
    auto_gf__2DisplayHintMessage_lp_type = lp_type;

    if (auto_gf__2DisplayHintMessage_Trigger == null) {
        auto_gf__2DisplayHintMessage_Trigger = TriggerCreate("auto_gf__2DisplayHintMessage_TriggerFunc");
    }

    TriggerExecute(auto_gf__2DisplayHintMessage_Trigger, false, false);
}

bool auto_gf__2DisplayHintMessage_TriggerFunc (bool testConds, bool runActions) {
    int lp_type = auto_gf__2DisplayHintMessage_lp_type;

    int auto8B10CEFC_val;
    int autoDAEFCE36_n;
    int autoDAEFCE36_i;

    // Variable Declarations
    int lv_localHintIndex;
    text lv_msg;
    unitgroup lv_danger;

    // Variable Initialization
    lv_danger = UnitGroupEmpty();

    // Implementation
    if (((lp_type == gv__2_HintType) || (lp_type == gv__2_HintTypeLast))) {
        return true;
    }
    else {
    }
    if ((gv__2_HintType != 0)) {
        if (((gv__2_HintOnDuration <= 4.5) || (gf__2HintTypeLevel(lp_type) <= gf__2HintTypeLevel(gv__2_HintType)))) {
            return true;
        }
        else {
        }
    }
    else {
    }
    gv__2_HintPlaying += 1;
    lv_localHintIndex = gv__2_HintPlaying;
    auto8B10CEFC_val = lp_type;
    if (auto8B10CEFC_val == 2) {
        lv_msg = StringExternal("Param/Value/BAED7128");
    }
    else if (auto8B10CEFC_val == 3) {
        lv_msg = StringExternal("Param/Value/D53141CE");
    }
    else if (auto8B10CEFC_val == 4) {
        lv_msg = StringExternal("Param/Value/661C5E85");
    }
    else if (auto8B10CEFC_val == 1) {
        lv_msg = StringExternal("Param/Value/42CE7F0B");
    }
    else {
        return true;
    }
    libStEx_gf_DisplayHintMessage(lv_msg, true, 1.0);
    gv__2_HintType = lp_type;
    gv__2_HintTypeLast = gv__2_HintType;
    gv__2_HintOnDuration = 0.0;
    autoDAEFCE36_n = 8;
    for (autoDAEFCE36_i = 1; autoDAEFCE36_i <= autoDAEFCE36_n; autoDAEFCE36_i += 1) {
        Wait(1.0, c_timeReal);
        gv__2_HintOnDuration += 1.0;
    }
    if ((gv__2_HintPlaying == lv_localHintIndex)) {
        libStEx_gf_ClearHintMessage();
        gv__2_HintType = 0;
        gv__2_HintOnDuration = 0.0;
        Wait(16.0, c_timeReal);
        if ((gv__2_HintPlaying == lv_localHintIndex)) {
            gv__2_HintPlaying = 0;
            gv__2_HintTypeLast = 0;
        }
        else {
        }
    }
    else {
    }
    return true;
}

point gf__2BTowerSuggestedEspacePosition (point lp_towerPos1, point lp_towerPos2, fixed lp_attackRange, point lp_heroPos) {
    // Variable Declarations
    fixed lv_y1;
    fixed lv_y2;
    fixed lv_y;
    point lv_heroPos1;
    point lv_suggestedPos;

    // Variable Initialization

    // Implementation
    lv_y1 = PointGetY(lp_towerPos1);
    lv_y2 = PointGetY(lp_towerPos2);
    lv_y = PointGetY(lp_heroPos);
    if ((lv_y <= lv_y1)) {
        lv_heroPos1 = lp_towerPos1;
    }
    else {
        if ((lv_y >= lv_y2)) {
            lv_heroPos1 = lp_towerPos2;
        }
        else {
            lv_heroPos1 = PointWithOffsetPolar(lp_towerPos1, (DistanceBetweenPoints(lp_towerPos1, lp_towerPos2) * (AbsF((lv_y - lv_y1)) / AbsF((lv_y2 - lv_y1)))), AngleBetweenPoints(lp_towerPos1, lp_towerPos2));
        }
    }
    lv_suggestedPos = PointWithOffsetPolar(lv_heroPos1, lp_attackRange, AngleBetweenPoints(lv_heroPos1, lp_heroPos));
    if ((PathingType(lv_suggestedPos) == c_pathingUnpathable)) {
        if ((RegionContainsPoint(RegionFromId(51), lv_suggestedPos) == true)) {
            return PointFromId(1864);
        }
        else {
        }
        if ((RegionContainsPoint(RegionFromId(54), lv_suggestedPos) == true)) {
            return PointFromId(1865);
        }
        else {
        }
    }
    else {
    }
    return lv_suggestedPos;
}

bool gf__2BTowerSuggestedEspacePositionGood (point lp_orderPos) {
    // Implementation
    if (((UnitIsAlive(UnitFromId(37)) == false) || (DistanceBetweenPoints(lp_orderPos, UnitGetPosition(UnitFromId(37))) > 10.0)) && ((UnitIsAlive(UnitFromId(39)) == false) || (DistanceBetweenPoints(lp_orderPos, UnitGetPosition(UnitFromId(39))) > 10.0))) {
        return true;
    }
    else {
    }
    return false;
}

point gf__2CFortSuggestedEspacePosition (point lp_fortPos, fixed lp_attackRange, point lp_heroPos) {
    // Variable Declarations
    point lv_suggestedPos;

    // Variable Initialization

    // Implementation
    lv_suggestedPos = PointWithOffsetPolar(lp_fortPos, lp_attackRange, AngleBetweenPoints(lp_fortPos, lp_heroPos));
    if ((PathingType(lv_suggestedPos) == c_pathingUnpathable)) {
        if ((RegionContainsPoint(RegionFromId(49), lv_suggestedPos) == true)) {
            return PointFromId(1797);
        }
        else {
        }
        if ((RegionContainsPoint(RegionFromId(50), lv_suggestedPos) == true)) {
            return PointFromId(1798);
        }
        else {
        }
    }
    else {
    }
    return lv_suggestedPos;
}

point gf__2CPalaceSuggestedEspacePosition (point lp_fortPos, fixed lp_attackRange, point lp_heroPos) {
    // Variable Declarations
    point lv_suggestedPos;

    // Variable Initialization

    // Implementation
    lv_suggestedPos = PointWithOffsetPolar(lp_fortPos, lp_attackRange, AngleBetweenPoints(lp_fortPos, lp_heroPos));
    if ((PathingType(lv_suggestedPos) == c_pathingUnpathable)) {
        if ((RegionContainsPoint(RegionFromId(45), lv_suggestedPos) == true)) {
            return PointFromId(1795);
        }
        else {
        }
        if ((RegionContainsPoint(RegionFromId(46), lv_suggestedPos) == true)) {
            return PointFromId(1796);
        }
        else {
        }
    }
    else {
    }
    if ((RegionContainsPoint(RegionFromId(58), lv_suggestedPos) == true)) {
        return PointFromId(479);
    }
    else {
    }
    if ((RegionContainsPoint(RegionFromId(59), lv_suggestedPos) == true)) {
        return PointFromId(938);
    }
    else {
    }
    return lv_suggestedPos;
}

void gf_MidGarrisonCinematicSendChaosWave (unitgroup lp_wave) {
    // Implementation
    UnitGroupIssueOrder(lp_wave, OrderTargetingPoint(AbilityCommand("attack", 0), PointFromId(35)), c_orderQueueReplace);
    UnitGroupIssueOrder(lp_wave, OrderTargetingPoint(AbilityCommand("attack", 0), PointFromId(22)), c_orderQueueAddToEnd);
    UnitGroupIssueOrder(lp_wave, OrderTargetingPoint(AbilityCommand("attack", 0), PointFromId(21)), c_orderQueueAddToEnd);
    UnitGroupIssueOrder(lp_wave, OrderTargetingPoint(AbilityCommand("attack", 0), PointFromId(20)), c_orderQueueAddToEnd);
    UnitGroupIssueOrder(lp_wave, OrderTargetingPoint(AbilityCommand("attack", 0), PointFromId(19)), c_orderQueueAddToEnd);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Initialization
//--------------------------------------------------------------------------------------------------
bool gt_Initialization_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerExecute(gt_Init01Data, true, false);
    TriggerExecute(gt_Init02Unit, true, false);
    TriggerExecute(gt_Init03UI, true, false);
    TriggerExecute(gt_Init04Environment, true, false);
    TriggerExecute(gt_Init05Ally, true, false);
    TriggerExecute(gt_IntroQ, true, true);
    TriggerExecute(gt__1AStartGameQ, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_Initialization_Init () {
    gt_Initialization = TriggerCreate("gt_Initialization_Func");
    TriggerAddEventMapInit(gt_Initialization);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Init 01 Data
//--------------------------------------------------------------------------------------------------
bool gt_Init01Data_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    GameCheatAllow(c_gameCheatVictory, false);
    GameCheatAllow(c_gameCheatDefeat, false);
    GameSetSpeedValue(c_gameSpeedNormal);
    GameSetSpeedLocked(true);
    CameraLockInput(gv_pLAYER_01_USER, true);
    ConversationDataPreloadLines("TutorialVO");
    ConversationDataPreloadLines("TutorialVO");
    libCore_gv_sYSGameMode = 1;
    libCore_gv_sYSStartGame = false;
    TriggerExecute(gt_StormInitializeMap, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_Init01Data_Init () {
    gt_Init01Data = TriggerCreate("gt_Init01Data_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Init 02 Unit
//--------------------------------------------------------------------------------------------------
bool gt_Init02Unit_Func (bool testConds, bool runActions) {
    // Variable Declarations
    point lv_position;

    // Variable Initialization

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

    TriggerEnable(libGame_gt_ConfineHeroesToBaseUntilCountdownEnds, false);
    gf_SpawnRaynor(PointFromId(7), false);
    gv_hERO_Instructor = UnitFromId(38);
    libNtve_gf_MakeUnitInvulnerable(gv_hERO_Instructor, true);
    lv_position = UnitGetPosition(gv_hERO_Instructor);
    PointSetFacing(lv_position, UnitGetFacing(gv_hERO_Instructor));
    libCore_gf_StorePointForUnit(gv_hERO_Instructor, 1, lv_position);
    gv_hERO_Diablo = UnitFromId(2082);
    libNtve_gf_MakeUnitInvulnerable(gv_hERO_Diablo, true);
    lv_position = UnitGetPosition(gv_hERO_Diablo);
    PointSetFacing(lv_position, UnitGetFacing(gv_hERO_Diablo));
    libCore_gf_StorePointForUnit(gv_hERO_Diablo, 1, lv_position);
    gv_hERO_Stitch = UnitFromId(1196);
    libNtve_gf_MakeUnitInvulnerable(gv_hERO_Stitch, true);
    PlayerSetState(gv_pLAYER_01_USER, c_playerStateFidgetingEnabled, false);
    PlayerSetState(gv_pLAYER_02_UTHER, c_playerStateFidgetingEnabled, false);
    libNtve_gf_MakeUnitUncommandable(gv_hERO_Raynor, false);
    libNtve_gf_MakeUnitInvulnerable(gv_hERO_Raynor, false);
    UnitXPGainEnable(gv_hERO_Raynor, null, false);
    UnitAbilityShow(gv_hERO_Raynor, "RaynorPenetratingRound", false);
    UnitAbilityShow(gv_hERO_Raynor, "RaynorInspire", false);
    UnitAbilityShow(gv_hERO_Raynor, "RaynorInspire", false);
    UnitAbilityShow(gv_hERO_Raynor, "RaynorRaynorsRaiders", false);
    UnitAbilityShow(gv_hERO_Raynor, "RaynorAdrenalineRush", false);
    UnitAbilityShow(gv_hERO_Raynor, "RaynorHyperion", false);
    UnitAbilityShow(gv_hERO_Raynor, "Mount", false);
    UnitAbilityShow(gv_hERO_Raynor, "PortBackToBase", false);
    UnitAbilityShow(gv_hERO_Raynor, "Que1Passive", false);
    UnitIssueOrder(gv_hERO_Raynor, Order(AbilityCommand("Dismount", 0)), c_orderQueueReplace);
    UnitXPGainEnable(gv_hERO_Instructor, null, false);
    UnitXPGainEnable(gv_hERO_Diablo, null, false);
    UnitXPGainEnable(gv_hERO_Stitch, null, false);
    gv__1A_Beacon = UnitFromId(1);
    libNtve_gf_ShowHideUnit(gv__1A_Beacon, false);
    gv__1B_AttackMoreSkeletonsA = UnitGroup(null, gv_pLAYER_12_CHAOS, RegionFromId(14), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    gv__1B_AttackMoreSkeletonsB = UnitGroup(null, gv_pLAYER_12_CHAOS, RegionFromId(15), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    gv__1B_AttackMoreSkeletonsC = UnitGroup(null, gv_pLAYER_12_CHAOS, RegionFromId(33), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    UnitGroupAddUnitGroup(gv__1B_AttackMoreSkeletonsAll, gv__1B_AttackMoreSkeletonsA);
    UnitGroupAddUnitGroup(gv__1B_AttackMoreSkeletonsAll, gv__1B_AttackMoreSkeletonsB);
    UnitGroupAddUnitGroup(gv__1B_AttackMoreSkeletonsAll, gv__1B_AttackMoreSkeletonsC);
    gv__1B_AttackMoreSkeletonsCount = UnitGroupCount(gv__1B_AttackMoreSkeletonsAll, c_unitCountAlive);
    UnitGroupLoopBegin(gv__1B_AttackMoreSkeletonsAll);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        lv_position = UnitGetPosition(UnitGroupLoopCurrent());
        PointSetFacing(lv_position, UnitGetFacing(UnitGroupLoopCurrent()));
        libCore_gf_StorePointForUnit(UnitGroupLoopCurrent(), 1, lv_position);
    }
    UnitGroupLoopEnd();
    gv__1C_Zombies1 = UnitGroup(null, gv_pLAYER_06_DIABLO, RegionFromId(19), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    gv__1C_Zombies2 = UnitGroup(null, gv_pLAYER_06_DIABLO, RegionFromId(20), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    gv__1C_Zombies3 = UnitGroup(null, gv_pLAYER_06_DIABLO, RegionFromId(28), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    gv__1C_Zombies4 = UnitGroup(null, gv_pLAYER_06_DIABLO, RegionFromId(21), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    gv__1C_Zombies5 = UnitGroup(null, gv_pLAYER_06_DIABLO, RegionFromId(27), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    gv__1C_Zombies6 = UnitGroup(null, gv_pLAYER_06_DIABLO, RegionFromId(1), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    UnitGroupAddUnitGroup(gv__1C_Zombies, gv__1C_Zombies1);
    UnitGroupAddUnitGroup(gv__1C_Zombies, gv__1C_Zombies2);
    UnitGroupAddUnitGroup(gv__1C_Zombies, gv__1C_Zombies3);
    UnitGroupAddUnitGroup(gv__1C_Zombies, gv__1C_Zombies4);
    UnitGroupAddUnitGroup(gv__1C_Zombies, gv__1C_Zombies5);
    UnitGroupAddUnitGroup(gv__1C_Zombies, gv__1C_Zombies6);
    gv__1C_ZombieCountTotal = UnitGroupCount(gv__1C_Zombies, c_unitCountAlive);
    UnitGroupLoopBegin(gv__1C_Zombies);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        libNtve_gf_ShowHideUnit(UnitGroupLoopCurrent(), false);
        libNtve_gf_PauseUnit(UnitGroupLoopCurrent(), true);
        libCore_gf_StorePointForUnit(UnitGroupLoopCurrent(), 1, UnitGetPosition(UnitGroupLoopCurrent()));
    }
    UnitGroupLoopEnd();
    gv__1C_InspireAllies = UnitGroup(null, gv_pLAYER_11_ORDER, RegionFromId(11), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    gv__1D_DiabloFightMinion = UnitGroup(null, gv_pLAYER_11_ORDER, RegionFromId(10), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    UnitGroupLoopBegin(gv__1D_DiabloFightMinion);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        libNtve_gf_PauseUnit(UnitGroupLoopCurrent(), true);
        libNtve_gf_ChangeUnitDamage(UnitGroupLoopCurrent(), 0, 1);
        libNtve_gf_ChangeUnitDamage(UnitGroupLoopCurrent(), 1, 1);
    }
    UnitGroupLoopEnd();
    gv__2B_Towers[1] = UnitFromId(37);
    gv__2B_Towers[2] = UnitFromId(39);
    UnitCreate(1, "TownGateL215BRUL", c_unitCreateIgnorePlacement, gv_pLAYER_12_CHAOS, UnitGetPosition(UnitFromId(955)), UnitGetFacing(UnitFromId(955)));
    gv_midDeath_TownGate = UnitLastCreated();
    ActorSend(libNtve_gf_MainActorofUnit(UnitLastCreated()), "Signal PlayBuild");
    libNtve_gf_ShowHideUnit(UnitLastCreated(), false);
    UnitBehaviorAddPlayer(UnitFromId(918), "CoreInvulnerability", gv_pLAYER_01_USER, 1);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_Init02Unit_Init () {
    gt_Init02Unit = TriggerCreate("gt_Init02Unit_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Init 03 UI
//--------------------------------------------------------------------------------------------------
bool gt_Init03UI_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    libNtve_gf_SetAlliance(gv_pLAYER_01_USER, gv_pLAYER_11_ORDER, 0);
    libNtve_gf_SetAlliance(gv_pLAYER_06_DIABLO, gv_pLAYER_12_CHAOS, 0);
    DialogControlSetVisible(libUIUI_gv_uIGameUIHandles.lv_minimapPanel, PlayerGroupAll(), false);
    UISetFrameVisible(PlayerGroupAll(), c_syncFrameTypeHelpMenuButton, false);
    DialogControlSetVisible(libUIUI_gv_uIGameUIHandles.lv_talentsButton, PlayerGroupAll(), false);
    UnitSetPropertyFixed(gv_hERO_Raynor, c_unitPropXP, 0.0);
    DialogControlHookupStandard(c_triggerControlTypePanel, "UIContainer/FullscreenUpperContainer/ChatDisplay");
    DialogControlSetPosition(DialogControlLastCreated(), PlayerGroupAll(), c_anchorBottom, 0, 200);
    DialogControlHookupStandard(c_triggerControlTypePanel, "UIContainer/FullscreenUpperContainer/ObjectivePanel");
    DialogControlSetPosition(DialogControlLastCreated(), PlayerGroupAll(), c_anchorBottomRight, -45, 640);
    DialogControlHookupStandard(c_triggerControlTypePanel, "UIContainer/ConsoleUIContainer/HeroCommandCardPanelFrame/AbilitiesBarGlass");
    DialogControlSetVisible(DialogControlLastCreated(), PlayerGroupAll(), false);
    DialogControlHookupStandard(c_triggerControlTypeButton, "UIContainer/ConsoleUIContainer/MinimapPanel/LockCameraButton");
    DialogControlSetVisible(DialogControlLastCreated(), PlayerGroupAll(), false);
    libStEx_gf_LockUnlockTutorialCamera(true);
    UISetHotkeyAllowed(PlayerGroupAll(), c_hotkeyCameraFollow, false);
    TriggerEnable(libUIUI_gt_InputTABKeyUp, false);
    TriggerEnable(libUIUI_gt_InputTABKeyDown, false);
    CameraForceFollowUnitGroup(gv_pLAYER_01_USER, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_Init03UI_Init () {
    gt_Init03UI = TriggerCreate("gt_Init03UI_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Init 04 Environment
//--------------------------------------------------------------------------------------------------
bool gt_Init04Environment_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    SoundtrackPlay(PlayerGroupAll(), c_soundtrackCategoryMusic, "Storm_Music_Tutorial_Main", c_soundtrackCueAny, c_soundtrackIndexAny, true);
    SoundtrackPlay(PlayerGroupAll(), c_soundtrackCategoryAmbience, "Storm_Ambience_Tutorial_Nexus_Platform", c_soundtrackCueAny, c_soundtrackIndexAny, true);
    GameSetLighting("StormRavenCourtFinal", 0.0);
    GameSetBackground(c_backgroundTerrain, "Storm_Doodad_CyberWorld_SkyParallax", 100.0);
    libCore_gf_AutoRevealRegion(RegionFromId(13), RegionFromId(13), 1);
    libCore_gf_AutoRevealRegion(RegionFromId(16), RegionFromId(16), 1);
    libCore_gf_AutoRevealRegion(RegionFromId(37), RegionFromId(37), 1);
    libCore_gf_AutoRevealRegion(RegionFromId(23), RegionFromId(23), 1);
    libCore_gf_AutoRevealRegion(RegionFromId(18), RegionFromId(18), 1);
    ConversationDataPreloadLines("TutorialVO");
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_Init04Environment_Init () {
    gt_Init04Environment = TriggerCreate("gt_Init04Environment_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Init 05 Ally
//--------------------------------------------------------------------------------------------------
bool gt_Init05Ally_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    libNtve_gf_SetAlliance(gv_pLAYER_01_USER, gv_pLAYER_02_UTHER, 0);
    libNtve_gf_SetAlliance(gv_pLAYER_01_USER, gv_pLAYER_06_DIABLO, 5);
    libNtve_gf_SetAlliance(gv_pLAYER_01_USER, gv_pLAYER_07_STITCHES, 5);
    libNtve_gf_SetAlliance(gv_pLAYER_01_USER, gv_pLAYER_11_ORDER, 0);
    libNtve_gf_SetAlliance(gv_pLAYER_01_USER, gv_pLAYER_12_CHAOS, 5);
    libNtve_gf_SetAlliance(gv_pLAYER_02_UTHER, gv_pLAYER_06_DIABLO, 5);
    libNtve_gf_SetAlliance(gv_pLAYER_02_UTHER, gv_pLAYER_07_STITCHES, 5);
    libNtve_gf_SetAlliance(gv_pLAYER_02_UTHER, gv_pLAYER_11_ORDER, 0);
    libNtve_gf_SetAlliance(gv_pLAYER_02_UTHER, gv_pLAYER_12_CHAOS, 5);
    libNtve_gf_SetAlliance(gv_pLAYER_06_DIABLO, gv_pLAYER_07_STITCHES, 0);
    libNtve_gf_SetAlliance(gv_pLAYER_06_DIABLO, gv_pLAYER_11_ORDER, 5);
    libNtve_gf_SetAlliance(gv_pLAYER_06_DIABLO, gv_pLAYER_12_CHAOS, 0);
    libNtve_gf_SetAlliance(gv_pLAYER_07_STITCHES, gv_pLAYER_11_ORDER, 5);
    libNtve_gf_SetAlliance(gv_pLAYER_07_STITCHES, gv_pLAYER_12_CHAOS, 0);
    libNtve_gf_SetAlliance(gv_pLAYER_11_ORDER, gv_pLAYER_12_CHAOS, 5);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_Init05Ally_Init () {
    gt_Init05Ally = TriggerCreate("gt_Init05Ally_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Storm - Initialize Map
//--------------------------------------------------------------------------------------------------
bool gt_StormInitializeMap_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerExecute(libAIAI_gt_IncludeAI, true, false);
    TriggerExecute(libGame_gt_IncludeGame, true, false);
    TriggerExecute(libGDHL_gt_IncludeGameDataHelper, true, false);
    TriggerExecute(libMapM_gt_IncludeMapMechanics, true, false);
    TriggerExecute(libSond_gt_IncludeSound, true, false);
    TriggerExecute(libSprt_gt_IncludeSupport, true, false);
    TriggerExecute(libUIUI_gt_IncludeUI, true, false);
    TriggerExecute(gt_StormHookupGlobalVariables, true, false);
    TriggerExecute(gt_StormHookupLaneData, true, false);
    TriggerExecute(gt_StormHookupJungleCreepData, true, false);
    TriggerExecute(gt_StormHookupTownData, true, false);
    libCore_gv_sYSTowns = true;
    libCore_gv_sYSJungleCreepCamps = false;
    libCore_gv_sYSJungleWatchTowers = false;
    libCore_gv_sYSTowerAI = true;
    libCore_gv_sYSMinionAI = false;
    libGame_gv_gameOverCallback = gt__2CPalaceDied;
    TriggerExecute(libCore_gt_InitializeStormMod, true, false);
    TriggerExecute(libGame_gt_RunAnimations, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_StormInitializeMap_Init () {
    gt_StormInitializeMap = TriggerCreate("gt_StormInitializeMap_Func");
    TriggerEnable(gt_StormInitializeMap, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Storm - Hookup Global Variables
//--------------------------------------------------------------------------------------------------
bool gt_StormHookupGlobalVariables_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_core = UnitFromId(154);
    libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_core = UnitFromId(918);
    libCore_gv_mAPOrderBaseRegion = RegionFromId(40);
    libCore_gv_mAPChaosBaseRegion = RegionFromId(42);
    libCore_gv_mAPExploredRegion = RegionPlayableMap();
    libCore_gv_mAPMapSoundtrack = "Storm_Music_Tutorial_Main";
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_StormHookupGlobalVariables_Init () {
    gt_StormHookupGlobalVariables = TriggerCreate("gt_StormHookupGlobalVariables_Func");
    TriggerEnable(gt_StormHookupGlobalVariables, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Storm - Hookup Lane Data
//--------------------------------------------------------------------------------------------------
bool gt_StormHookupLaneData_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_structureCount;
    int lv_waypointCount;

    // Variable Initialization

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

    libGame_gv_laneCount += 1;
    lv_structureCount = 0;
    lv_waypointCount = 0;
    libGame_gv_laneData[libGame_gv_laneCount].lv_laneName = StringExternal("Param/Value/1B32A30B");
    lv_structureCount += 1;
    libGame_gv_laneData[libGame_gv_laneCount].lv_orderStructures[lv_structureCount] = UnitFromId(154);
    libGame_gv_laneData[libGame_gv_laneCount].lv_chaosStructures[lv_structureCount] = UnitFromId(918);
    libGame_gv_laneData[libGame_gv_laneCount].lv_structureCount = lv_structureCount;
    lv_waypointCount += 1;
    libGame_gv_laneData[libGame_gv_laneCount].lv_waypoints[lv_waypointCount] = PointFromId(24);
    lv_waypointCount += 1;
    libGame_gv_laneData[libGame_gv_laneCount].lv_waypoints[lv_waypointCount] = PointFromId(15);
    lv_waypointCount += 1;
    libGame_gv_laneData[libGame_gv_laneCount].lv_waypoints[lv_waypointCount] = PointFromId(17);
    lv_waypointCount += 1;
    libGame_gv_laneData[libGame_gv_laneCount].lv_waypoints[lv_waypointCount] = PointFromId(18);
    lv_waypointCount += 1;
    libGame_gv_laneData[libGame_gv_laneCount].lv_waypoints[lv_waypointCount] = PointFromId(19);
    lv_waypointCount += 1;
    libGame_gv_laneData[libGame_gv_laneCount].lv_waypoints[lv_waypointCount] = PointFromId(20);
    lv_waypointCount += 1;
    libGame_gv_laneData[libGame_gv_laneCount].lv_waypoints[lv_waypointCount] = PointFromId(21);
    lv_waypointCount += 1;
    libGame_gv_laneData[libGame_gv_laneCount].lv_waypoints[lv_waypointCount] = PointFromId(22);
    lv_waypointCount += 1;
    libGame_gv_laneData[libGame_gv_laneCount].lv_waypoints[lv_waypointCount] = PointFromId(23);
    lv_waypointCount += 1;
    libGame_gv_laneData[libGame_gv_laneCount].lv_waypoints[lv_waypointCount] = PointFromId(25);
    libGame_gv_laneData[libGame_gv_laneCount].lv_waypointCount = lv_waypointCount;
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_StormHookupLaneData_Init () {
    gt_StormHookupLaneData = TriggerCreate("gt_StormHookupLaneData_Func");
    TriggerEnable(gt_StormHookupLaneData, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Storm - Hookup Jungle Creep Data
//--------------------------------------------------------------------------------------------------
bool gt_StormHookupJungleCreepData_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    libMapM_gv_jungleNumberOfCreepCamps = 0;
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_StormHookupJungleCreepData_Init () {
    gt_StormHookupJungleCreepData = TriggerCreate("gt_StormHookupJungleCreepData_Func");
    TriggerEnable(gt_StormHookupJungleCreepData, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Storm - Hookup Town Data
//--------------------------------------------------------------------------------------------------
bool gt_StormHookupTownData_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_lane;
    int lv_town;

    // Variable Initialization

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

    lv_lane = 1;
    lv_town += 1;
    libGame_gv_townTownData[lv_town].lv_lane = lv_lane;
    libGame_gv_townTownData[lv_town].lv_owner = libCore_gv_cOMPUTER_TeamOrder;
    libGame_gv_townTownData[lv_town].lv_townRegion = RegionFromId(43);
    libGame_gv_townTownData[lv_town].lv_makesCoreVulnerableWhenKilled = true;
    lv_lane = 1;
    lv_town += 1;
    libGame_gv_townTownData[lv_town].lv_lane = lv_lane;
    libGame_gv_townTownData[lv_town].lv_owner = libCore_gv_cOMPUTER_TeamChaos;
    libGame_gv_townTownData[lv_town].lv_townRegion = RegionFromId(44);
    libGame_gv_townTownData[lv_town].lv_makesCoreVulnerableWhenKilled = true;
    libGame_gv_townTownCount = lv_town;
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_StormHookupTownData_Init () {
    gt_StormHookupTownData = TriggerCreate("gt_StormHookupTownData_Func");
    TriggerEnable(gt_StormHookupTownData, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Storm - Start Game
//--------------------------------------------------------------------------------------------------
bool gt_StormStartGame_Func (bool testConds, bool runActions) {
    int auto2C07EE6A_ae;
    int auto2C07EE6A_ai;
    int autoE9D8EA7C_ae;
    int autoE9D8EA7C_ai;

    // Variable Declarations
    int lv_itTeam;
    int lv_itPlayer;

    // Variable Initialization

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

    libAIAI_gf_HeroAIStartAI();
    TimerStart(libGame_gv_openTheGatesTimer, 0.0625, false, c_timeGame);
    TimerStart(libGame_gv_totalTime, c_timerDurationInfinite, false, c_timeGame);
    libGame_gf_HeroSelectionSetBNetHeroAndSkinSelectionsForAllPlayers();
    libAIAI_gf_HeroAIGeneralPreInit();
    auto2C07EE6A_ae = libCore_gv_bALMaxPlayers;
    auto2C07EE6A_ai = 1;
    lv_itPlayer = 1;
    for ( ; ( (auto2C07EE6A_ai >= 0 && lv_itPlayer <= auto2C07EE6A_ae) || (auto2C07EE6A_ai <= 0 && lv_itPlayer >= auto2C07EE6A_ae) ) ; lv_itPlayer += auto2C07EE6A_ai ) {
        libGame_gv_players[lv_itPlayer].lv_heroIndex = 0;
    }
    libGame_gv_players[gv_pLAYER_01_USER].lv_heroIndex = libStEx_gf_HeroIndex("Raynor");
    libGame_gv_players[gv_pLAYER_02_UTHER].lv_heroIndex = libStEx_gf_HeroIndex("Uther");
    libGame_gv_players[gv_pLAYER_06_DIABLO].lv_heroIndex = libStEx_gf_HeroIndex("Diablo");
    libGame_gv_players[gv_pLAYER_07_STITCHES].lv_heroIndex = libStEx_gf_HeroIndex("Stitches");
    autoE9D8EA7C_ae = libCore_gv_bALMaxTeams;
    autoE9D8EA7C_ai = 1;
    lv_itTeam = 1;
    for ( ; ( (autoE9D8EA7C_ai >= 0 && lv_itTeam <= autoE9D8EA7C_ae) || (autoE9D8EA7C_ai <= 0 && lv_itTeam >= autoE9D8EA7C_ae) ) ; lv_itTeam += autoE9D8EA7C_ai ) {
        libGame_gf_PreloadHeroesForTeam(lv_itTeam);
    }
    Wait(libGame_gv_heroSpawnDelay_C, c_timeGame);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_StormStartGame_Init () {
    gt_StormStartGame = TriggerCreate("gt_StormStartGame_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Debug - Stage 2 (Abilities)
//--------------------------------------------------------------------------------------------------
bool gt_DebugStage2Abilities_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerStop(gt__1AStartGameQ);
    TriggerEnable(gt__1AMoveOrderIssued, false);
    TriggerEnable(gt__1BAMoveEnemiesApproachedQ, false);
    TriggerEnable(gt__1BAMoveAttackOrderIssued, false);
    UnitGroupLoopBegin(gv__1B_AttackMoreSkeletonsAll);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        UnitRemove(UnitGroupLoopCurrent());
    }
    UnitGroupLoopEnd();
    UnitSetPosition(gv_hERO_Raynor, PointFromId(1203), false);
    UnitSetFacing(gv_hERO_Raynor, PointGetFacing(PointFromId(1203)), 0.0);
    TriggerExecute(gt__1CPenRoundQ, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_DebugStage2Abilities_Init () {
    gt_DebugStage2Abilities = TriggerCreate("gt_DebugStage2Abilities_Func");
    TriggerAddEventChatMessage(gt_DebugStage2Abilities, c_playerAny, "s2", true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Debug - Stage 3 (Camera)
//--------------------------------------------------------------------------------------------------
bool gt_DebugStage3Camera_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerStop(gt__1AStartGameQ);
    TriggerEnable(gt__1AMoveOrderIssued, false);
    TriggerEnable(gt__1BAMoveAttackOrderIssued, false);
    UnitGroupLoopBegin(gv__1C_Zombies);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        UnitRemove(UnitGroupLoopCurrent());
    }
    UnitGroupLoopEnd();
    RegionPlayableMapSet(RegionFromId(2));
    libStEx_gf_MoveUnit(gv_hERO_Raynor, PointFromId(528), false);
    DialogControlSetVisible(libUIUI_gv_uIGameUIHandles.lv_minimapPanel, PlayerGroupAll(), true);
    UnitAbilityShow(gv_hERO_Raynor, "RaynorPenetratingRound", true);
    UnitAbilityShow(gv_hERO_Raynor, "RaynorInspire", true);
    TriggerExecute(gt__1DCameraLockQ, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_DebugStage3Camera_Init () {
    gt_DebugStage3Camera = TriggerCreate("gt_DebugStage3Camera_Func");
    TriggerAddEventChatMessage(gt_DebugStage3Camera, c_playerAny, "s3", true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Debug - Stage 4 (Diablo Fight)
//--------------------------------------------------------------------------------------------------
bool gt_DebugStage4DiabloFight_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerStop(gt__1AStartGameQ);
    TriggerEnable(gt__1AMoveOrderIssued, false);
    TriggerEnable(gt__1BAMoveAttackOrderIssued, false);
    UnitGroupLoopBegin(gv__1C_Zombies);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        UnitRemove(UnitGroupLoopCurrent());
    }
    UnitGroupLoopEnd();
    UnitGroupLoopBegin(gv__1D_DiabloFightMinion);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        UnitRemove(UnitGroupLoopCurrent());
    }
    UnitGroupLoopEnd();
    UnitSetPropertyFixed(gv_hERO_Diablo, c_unitPropLifePercent, 55.0);
    libNtve_gf_ChangeUnitDamage(gv_hERO_Diablo, 0, 0);
    libNtve_gf_ChangeUnitDamage(gv_hERO_Diablo, 1, 0);
    libNtve_gf_MakeUnitInvulnerable(gv_hERO_Diablo, false);
    UnitSetPosition(gv_hERO_Diablo, libCore_gf_PointStoredForUnit(gv_hERO_Diablo, 1), false);
    if ((libNtve_gf_UnitIsHidden(gv_hERO_Diablo) == true)) {
        libNtve_gf_ShowHideUnit(gv_hERO_Diablo, true);
    }
    else {
    }
    libStEx_gf_MoveUnit(gv_hERO_Raynor, PointFromId(528), false);
    UnitSetFacing(gv_hERO_Raynor, PointGetFacing(PointFromId(528)), 0.0);
    DialogControlSetVisible(libUIUI_gv_uIGameUIHandles.lv_minimapPanel, PlayerGroupAll(), true);
    gf_SetPlayableWithLooseCameraBounds(RegionFromId(41));
    UnitAbilityShow(gv_hERO_Raynor, "RaynorPenetratingRound", true);
    UnitAbilityShow(gv_hERO_Raynor, "RaynorInspire", true);
    VisRevealArea(1, RegionFromId(36), 0.0, false);
    gv__1D_CameraLockButtonClicked = true;
    TriggerEnable(gt__1DCameraUnlocked, true);
    TriggerExecute(gt__1DDiabloFightQ, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_DebugStage4DiabloFight_Init () {
    gt_DebugStage4DiabloFight = TriggerCreate("gt_DebugStage4DiabloFight_Func");
    TriggerAddEventChatMessage(gt_DebugStage4DiabloFight, c_playerAny, "s4", true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Debug - Stage 5 (Town)
//--------------------------------------------------------------------------------------------------
bool gt_DebugStage5Town_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerStop(gt__1AStartGameQ);
    TriggerEnable(gt__1AMoveOrderIssued, false);
    TriggerEnable(gt__1BAMoveAttackOrderIssued, false);
    UnitGroupLoopBegin(gv__1C_Zombies);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        UnitRemove(UnitGroupLoopCurrent());
    }
    UnitGroupLoopEnd();
    DialogControlSetVisible(libUIUI_gv_uIGameUIHandles.lv_minimapPanel, PlayerGroupAll(), true);
    RegionPlayableMapSet(RegionFromId(22));
    UnitSetPosition(gv_hERO_Raynor, PointFromId(697), false);
    UnitAbilityShow(gv_hERO_Raynor, "RaynorPenetratingRound", true);
    UnitAbilityShow(gv_hERO_Raynor, "RaynorInspire", true);
    UnitAbilityShow(gv_hERO_Raynor, "PortBackToBase", true);
    UnitKill(gv_hERO_Diablo);
    gv__1D_CameraLockButtonClicked = true;
    TriggerEnable(gt__1DCameraUnlocked, true);
    TriggerExecute(gt__2ATeleportBaseCompleted, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_DebugStage5Town_Init () {
    gt_DebugStage5Town = TriggerCreate("gt_DebugStage5Town_Func");
    TriggerAddEventChatMessage(gt_DebugStage5Town, c_playerAny, "s5", true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Debug - Stage 6 (Victory)
//--------------------------------------------------------------------------------------------------
bool gt_DebugStage6Victory_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TransmissionClearAll();
    TriggerQueueClear(c_triggerQueueRemove);
    TriggerStop(gt__1AStartGameQ);
    TriggerEnable(gt__1AMoveOrderIssued, false);
    TriggerEnable(gt__1BAMoveAttackOrderIssued, false);
    UnitGroupLoopBegin(gv__1C_Zombies);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        UnitRemove(UnitGroupLoopCurrent());
    }
    UnitGroupLoopEnd();
    libGame_gv_gameOverCallback = gt__2CPalaceDied;
    UnitKill(UnitFromId(918));
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_DebugStage6Victory_Init () {
    gt_DebugStage6Victory = TriggerCreate("gt_DebugStage6Victory_Func");
    TriggerAddEventChatMessage(gt_DebugStage6Victory, c_playerAny, "s6", true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Debug - Temp
//--------------------------------------------------------------------------------------------------
bool gt_DebugTemp_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {
            return false;
        }
    }

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

    UIDisplayMessage(PlayerGroupAll(), c_messageAreaSubtitle, StringToText(PlayerGetHotkeyProfile(1)));
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_DebugTemp_Init () {
    gt_DebugTemp = TriggerCreate("gt_DebugTemp_Func");
    TriggerAddEventChatMessage(gt_DebugTemp, c_playerAny, "-te", false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Add Reference Card - Move
//--------------------------------------------------------------------------------------------------
bool gt_AddReferenceCardMove_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    Wait(1.0, c_timeGame);
    libUIUI_gf_AddTutorialReferenceItemPreset(0);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_AddReferenceCardMove_Init () {
    gt_AddReferenceCardMove = TriggerCreate("gt_AddReferenceCardMove_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Add Reference Card - Attack
//--------------------------------------------------------------------------------------------------
bool gt_AddReferenceCardAttack_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    Wait(2.0, c_timeGame);
    libUIUI_gf_AddTutorialReferenceItemPreset(1);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_AddReferenceCardAttack_Init () {
    gt_AddReferenceCardAttack = TriggerCreate("gt_AddReferenceCardAttack_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Add Reference Card - Penetrating Round
//--------------------------------------------------------------------------------------------------
bool gt_AddReferenceCardPenetratingRound_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    Wait(2.0, c_timeGame);
    libUIUI_gf_AddTutorialReferenceItemPreset(2);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_AddReferenceCardPenetratingRound_Init () {
    gt_AddReferenceCardPenetratingRound = TriggerCreate("gt_AddReferenceCardPenetratingRound_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Add Reference Card - Inspire
//--------------------------------------------------------------------------------------------------
bool gt_AddReferenceCardInspire_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    Wait(2.0, c_timeGame);
    libUIUI_gf_AddTutorialReferenceItemPreset(3);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_AddReferenceCardInspire_Init () {
    gt_AddReferenceCardInspire = TriggerCreate("gt_AddReferenceCardInspire_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Add Reference Card - Camera
//--------------------------------------------------------------------------------------------------
bool gt_AddReferenceCardCamera_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    Wait(2.0, c_timeGame);
    libUIUI_gf_AddTutorialReferenceItemPreset(4);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_AddReferenceCardCamera_Init () {
    gt_AddReferenceCardCamera = TriggerCreate("gt_AddReferenceCardCamera_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1_Raynor Won't Die
//--------------------------------------------------------------------------------------------------
bool gt__1_RaynorWontDie_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    if ((UnitGetPropertyFixed(gv_hERO_Raynor, c_unitPropLifePercent, c_unitPropCurrent) >= 50.0)) {
        libNtve_gf_ChangeUnitDamage(gv_hERO_Raynor, 0, 0);
        if ((UnitHasBehavior2(gv_hERO_Raynor, "TutorialLifeRegeneration") == true)) {
            UnitBehaviorRemovePlayer(gv_hERO_Raynor, "TutorialLifeRegeneration", gv_pLAYER_01_USER, 1);
        }
        else {
        }
    }
    else if ((UnitGetPropertyFixed(gv_hERO_Raynor, c_unitPropLifePercent, c_unitPropCurrent) >= 20.0)) {
        libNtve_gf_ChangeUnitDamage(gv_hERO_Raynor, 0, 2);
    }
    else if (true) {
        if ((UnitHasBehavior2(gv_hERO_Raynor, "DamageTakenNone") == false)) {
            UnitBehaviorAddPlayer(gv_hERO_Raynor, "TutorialLifeRegeneration", gv_pLAYER_01_USER, 1);
            libNtve_gf_ChangeUnitDamage(gv_hERO_Raynor, 0, 1);
        }
        else {
        }
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1_RaynorWontDie_Init () {
    gt__1_RaynorWontDie = TriggerCreate("gt__1_RaynorWontDie_Func");
    TriggerEnable(gt__1_RaynorWontDie, false);
    TriggerAddEventUnitProperty(gt__1_RaynorWontDie, UnitRefFromVariable("gv_hERO_Raynor"), c_unitPropLifePercent);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1A - Start Game Q
//--------------------------------------------------------------------------------------------------
bool gt__1AStartGameQ_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    SoundtrackPlay(PlayerGroupAll(), c_soundtrackCategoryMusic, "Storm_Music_Ravens_Court", c_soundtrackCueAny, c_soundtrackIndexAny, true);
    TriggerEnable(gt__1AMoveOrderIssued, true);
    Wait(2.0, c_timeReal);
    TriggerQueueEnter();
    gv__1A_BeaconObjectiveCreated = true;
    if ((gv__1A_BeaconReached == false)) {
        if ((gv__1A_BeaconReached == false)) {
            TriggerExecute(gt_ObjectiveMoveToBeaconCreate, true, true);
        }
        else {
        }
        if ((gv__1A_BeaconOrderIssued == false)) {
            libStEx_gf_DisplayHintMessage(TextExpressionAssemble("Param/Expression/BE8EB6D7"), true, 1.5);
            Wait(2.0, c_timeReal);
        }
        else {
        }
        if ((gv__1A_BeaconReached == false)) {
            TriggerExecute(gt__1ABeaconHighlight, true, false);
            Wait(2.0, c_timeGame);
        }
        else {
        }
    }
    else {
    }
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1AStartGameQ_Init () {
    gt__1AStartGameQ = TriggerCreate("gt__1AStartGameQ_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1A - Beacon Highlight
//--------------------------------------------------------------------------------------------------
bool gt__1ABeaconHighlight_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_target;

    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((gv__1A_BeaconReached == false))) {
            return false;
        }

        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    lv_target = gv__1A_Beacon;
    libNtve_gf_ShowHideUnit(gv__1A_Beacon, true);
    libNtve_gf_PlayAnimation(libNtve_gf_MainActorofUnit(gv__1A_Beacon), c_animNameDefault, "Birth", c_animFlagNonLooping, c_animTimeDefault);
    libCore_gf_AttachReticleEffectAndTextTagOnUnit(0, 1, StringExternal("Param/Value/B000A236"), lv_target, "Ref_Center");
    ActorSend(libNtve_gf_ActorLastCreated(), "Destroy Immediate");
    libCore_gf_StoreTextTagForUnit(lv_target, 1, TextTagLastCreated());
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1ABeaconHighlight_Init () {
    gt__1ABeaconHighlight = TriggerCreate("gt__1ABeaconHighlight_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1A - Beacon Unhighlight
//--------------------------------------------------------------------------------------------------
bool gt__1ABeaconUnhighlight_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_target;

    // Variable Initialization

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

    lv_target = gv__1A_Beacon;
    if ((libCore_gf_ActorStoredForUnit(lv_target, 1) != null)) {
        libNtve_gf_KillModel(libCore_gf_ActorStoredForUnit(lv_target, 1));
        libCore_gf_StoreActorForUnit(lv_target, 1, null);
    }
    else {
    }
    if ((libCore_gf_TextTagStoredForUnit(lv_target, 1) != c_textTagNone)) {
        TextTagDestroy(libCore_gf_TextTagStoredForUnit(lv_target, 1));
        libCore_gf_StoreTextTagForUnit(lv_target, 1, c_textTagNone);
    }
    else {
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1ABeaconUnhighlight_Init () {
    gt__1ABeaconUnhighlight = TriggerCreate("gt__1ABeaconUnhighlight_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1A - Move Order Issued
//--------------------------------------------------------------------------------------------------
bool gt__1AMoveOrderIssued_Func (bool testConds, bool runActions) {
    int auto15BBBBE0_val;
    int auto03E3D281_val;

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

    TriggerEnable(TriggerGetCurrent(), false);
    gv__1A_BeaconOrderIssued = true;
    auto15BBBBE0_val = EventMouseClickedButton();
    if (auto15BBBBE0_val == c_mouseButtonLeft) {
        libStEx_gf_HotkeyProfile_SetSmartCommandMouseButton(gv_pLAYER_01_USER, 1);
    }
    else if (auto15BBBBE0_val == c_mouseButtonRight) {
        libStEx_gf_HotkeyProfile_SetSmartCommandMouseButton(gv_pLAYER_01_USER, 2);
    }
    else {
    }
    gv__1A_BeaconOrderIssued = true;
    libStEx_gf_ClearHintMessage();
    libNtve_gf_PauseUnit(gv_hERO_Raynor, false);
    UnitAbilityEnable(gv_hERO_Raynor, "move", true);
    UnitIssueOrder(gv_hERO_Raynor, OrderTargetingPoint(AbilityCommand("move", 0), Point(EventMouseClickedPosXWorld(), EventMouseClickedPosYWorld())), c_orderQueueReplace);
    Wait(2.0, c_timeGame);
    gv__1A_BeaconMoveButtonCurrent = libStEx_gf_HotkeyProfile_SmartCommandMouseButton(gv_pLAYER_01_USER);
    auto03E3D281_val = gv__1A_BeaconMoveButtonCurrent;
    if (auto03E3D281_val == 1) {
        gv__1A_BeaconMoveButtonOther = 2;
    }
    else if (auto03E3D281_val == 2) {
        gv__1A_BeaconMoveButtonOther = 1;
    }
    else {
        gv__1A_BeaconMoveButtonOther = 1;
    }
    TextExpressionSetToken("Param/Expression/531D305F", "A", libStEx_gf_HotkeyProfile_MouseButtonText(gv__1A_BeaconMoveButtonCurrent));
    TextExpressionSetToken("Param/Expression/531D305F", "B", libStEx_gf_HotkeyProfile_MouseButtonText(gv__1A_BeaconMoveButtonOther));
    UIShowCustomDialog(libCore_gv_playerGroupFromPlayer[gv_pLAYER_01_USER], 1, null, TextExpressionAssemble("Param/Expression/531D305F"), true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1AMoveOrderIssued_Init () {
    gt__1AMoveOrderIssued = TriggerCreate("gt__1AMoveOrderIssued_Func");
    TriggerEnable(gt__1AMoveOrderIssued, false);
    TriggerAddEventMouseClicked(gt__1AMoveOrderIssued, gv_pLAYER_01_USER, c_mouseButtonLeft, true);
    TriggerAddEventMouseClicked(gt__1AMoveOrderIssued, gv_pLAYER_01_USER, c_mouseButtonRight, true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1A - Move Button Selected
//--------------------------------------------------------------------------------------------------
bool gt__1AMoveButtonSelected_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerEnable(TriggerGetCurrent(), false);
    if ((EventCustomDialogResult() == 2)) {
        libStEx_gf_HotkeyProfile_SetSmartCommandMouseButton(gv_pLAYER_01_USER, gv__1A_BeaconMoveButtonOther);
    }
    else {
    }
    TriggerExecute(gt_AddReferenceCardMove, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1AMoveButtonSelected_Init () {
    gt__1AMoveButtonSelected = TriggerCreate("gt__1AMoveButtonSelected_Func");
    TriggerAddEventCustomDialogDismissed(gt__1AMoveButtonSelected, c_playerAny, 0);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1A - Beacon Reached
//--------------------------------------------------------------------------------------------------
bool gt__1ABeaconReached_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerEnable(TriggerGetCurrent(), false);
    gv__1A_BeaconOrderIssued = true;
    gv__1A_BeaconReached = true;
    libNtve_gf_MakeUnitUncommandable(gv_hERO_Raynor, true);
    UnitIssueOrder(gv_hERO_Raynor, OrderTargetingPoint(AbilityCommand("move", 0), UnitGetPosition(gv__1A_Beacon)), c_orderQueueReplace);
    UnitIssueOrder(gv_hERO_Raynor, OrderTargetingPoint(AbilityCommand("move", 4), PointWithOffsetPolar(UnitGetPosition(gv__1A_Beacon), 1.0, AngleBetweenPoints(PointFromId(34), UnitGetPosition(gv__1A_Beacon)))), c_orderQueueAddToEnd);
    libStEx_gf_ClearHintMessage();
    TriggerExecute(gt_AddReferenceCardMove, true, false);
    TransmissionClearAll();
    TriggerExecute(gt__1ABeaconUnhighlight, true, false);
    SoundStop(gv__1A_BeaconSound, true);
    SoundPlayAtPointForPlayer(SoundLink("Tutorial_Beacon_Death", -1), c_maxPlayers, PlayerGroupAll(), UnitGetPosition(gv__1A_Beacon), 0.0, 100.0, 0.0);
    UnitKill(gv__1A_Beacon);
    gv__1A_Beacon = null;
    while (!((gv__1A_BeaconObjectiveCreated == true))) {
        Wait(0.125, c_timeGame);
    }
    TriggerExecute(gt_ObjectiveMoveToBeaconComplete, true, false);
    Wait(1.0, c_timeReal);
    TriggerExecute(gt__1BAttackSkeleton1Q, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1ABeaconReached_Init () {
    gt__1ABeaconReached = TriggerCreate("gt__1ABeaconReached_Func");
    TriggerAddEventUnitRange(gt__1ABeaconReached, UnitRefFromVariable("gv_hERO_Raynor"), UnitFromId(1), 2.5, true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1A - Beacon Sound
//--------------------------------------------------------------------------------------------------
bool gt__1ABeaconSound_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    SoundPlayOnUnitForPlayer(SoundLink("Tutorial_Beacon_Birth", -1), c_maxPlayers, PlayerGroupAll(), gv__1A_Beacon, 0.0, 100.0, 0.0);
    SoundPlayOnUnitForPlayer(SoundLink("Tutorial_Beacon_Loop", -1), c_maxPlayers, PlayerGroupAll(), gv__1A_Beacon, 0.0, 100.0, 0.0);
    gv__1A_BeaconSound = SoundLastPlayed();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1ABeaconSound_Init () {
    gt__1ABeaconSound = TriggerCreate("gt__1ABeaconSound_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1B - Attack Skeleton1 Q
//--------------------------------------------------------------------------------------------------
bool gt__1BAttackSkeleton1Q_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerExecute(gt_MidSkeletonAttackQ, true, true);
    TriggerEnable(gt__1_RaynorWontDie, true);
    TriggerEnable(libGame_gt_HeroDeathHeroDies, false);
    Wait(1.0, c_timeGame);
    TriggerQueueEnter();
    TriggerExecute(gt_ObjectiveKilltheUndeadCreate, true, true);
    gv__1B_AttackSkeleton1ObjectiveCreated = true;
    if ((gv__1B_AttackSkeleton1Attacked == false)) {
        TextExpressionSetToken("Param/Expression/7AF06A17", "A", StringExternal("Param/Value/1E7A29F6"));
        TextExpressionSetToken("Param/Expression/7AF06A17", "B", libStEx_gf_HotkeyProfile_MouseButtonImageStringTag(1, libStEx_gv_sEC_MouseButtonWidth, libStEx_gv_sEC_MouseButtonHeight));
        libStEx_gf_DisplayHintMessage(TextExpressionAssemble("Param/Expression/7AF06A17"), true, 1.5);
        Wait(2.0, c_timeReal);
    }
    else {
    }
    if ((gv__1B_AttackSkeleton1Attacked == false)) {
        TriggerExecute(gt__1BAttackSkeleton1Highlight, true, false);
        Wait(2.0, c_timeReal);
    }
    else {
    }
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1BAttackSkeleton1Q_Init () {
    gt__1BAttackSkeleton1Q = TriggerCreate("gt__1BAttackSkeleton1Q_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1B - Attack Skeleton1 Highlight
//--------------------------------------------------------------------------------------------------
bool gt__1BAttackSkeleton1Highlight_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_target;

    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((gv__1B_AttackSkeleton1Attacked == false))) {
            return false;
        }

        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    lv_target = gv__1B_AttackSkeleton1;
    libNtve_gf_CreatePingFacingAngle(PlayerGroupAll(), "PingObjective", UnitGetPosition(lv_target), ColorWithAlpha(0.00, 100.00, 0.00, 0.00), 0.0, 270.0);
    libCore_gf_StorePingForUnit(lv_target, 1, PingLastCreated());
    libCore_gf_AttachReticleEffectAndTextTagOnUnit(2, 2, StringExternal("Param/Value/35E26E0D"), lv_target, "Ref_Center");
    TextTagAttachToUnit(TextTagLastCreated(), lv_target, 0.5);
    libCore_gf_StoreActorForUnit(lv_target, 1, libNtve_gf_ActorLastCreated());
    libCore_gf_StoreTextTagForUnit(lv_target, 1, TextTagLastCreated());
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1BAttackSkeleton1Highlight_Init () {
    gt__1BAttackSkeleton1Highlight = TriggerCreate("gt__1BAttackSkeleton1Highlight_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1B - Attack Skeleton1 Unhighlight
//--------------------------------------------------------------------------------------------------
bool gt__1BAttackSkeleton1Unhighlight_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_target;

    // Variable Initialization

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

    lv_target = gv__1B_AttackSkeleton1;
    if ((libCore_gf_PingStoredForUnit(lv_target, 1) != c_invalidPingId)) {
        PingDestroy(libCore_gf_PingStoredForUnit(lv_target, 1));
        libCore_gf_StorePingForUnit(lv_target, 1, c_invalidPingId);
    }
    else {
    }
    if ((libCore_gf_ActorStoredForUnit(lv_target, 1) != null)) {
        libNtve_gf_KillModel(libCore_gf_ActorStoredForUnit(lv_target, 1));
        libCore_gf_StoreActorForUnit(lv_target, 1, null);
    }
    else {
    }
    if ((libCore_gf_TextTagStoredForUnit(lv_target, 1) != c_textTagNone)) {
        TextTagDestroy(libCore_gf_TextTagStoredForUnit(lv_target, 1));
        libCore_gf_StoreTextTagForUnit(lv_target, 1, c_textTagNone);
    }
    else {
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1BAttackSkeleton1Unhighlight_Init () {
    gt__1BAttackSkeleton1Unhighlight = TriggerCreate("gt__1BAttackSkeleton1Unhighlight_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1B - Attack Skeleton1 Attacked
//--------------------------------------------------------------------------------------------------
bool gt__1BAttackSkeleton1Attacked_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((EventUnitTarget() == gv_hERO_Raynor))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    gv__1B_AttackSkeleton1Attacked = true;
    libStEx_gf_ClearHintMessage();
    UnitAbilityEnable(gv_hERO_Raynor, "move", true);
    TriggerExecute(gt_AddReferenceCardAttack, true, false);
    TriggerExecute(gt__1BAttackSkeleton1Unhighlight, true, false);
    libNtve_gf_PauseUnit(gv__1B_AttackSkeleton1, false);
    UnitIssueOrder(gv__1B_AttackSkeleton1, OrderTargetingUnit(AbilityCommand("attack", 0), gv_hERO_Raynor), c_orderQueueReplace);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1BAttackSkeleton1Attacked_Init () {
    gt__1BAttackSkeleton1Attacked = TriggerCreate("gt__1BAttackSkeleton1Attacked_Func");
    TriggerAddEventUnitAttacked2(gt__1BAttackSkeleton1Attacked, UnitRefFromVariable("gv__1B_AttackSkeleton1"), null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1B - Attack Skeleton1 Dies
//--------------------------------------------------------------------------------------------------
bool gt__1BAttackSkeleton1Dies_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerEnable(TriggerGetCurrent(), false);
    gv__1B_AttackSkeleton1Attacked = true;
    gv__1B_AttackSkeleton1Killed = true;
    libStEx_gf_ClearHintMessage();
    gf_SetPlayableWithLooseCameraBounds(RegionFromId(39));
    TriggerExecute(gt_AddReferenceCardAttack, true, false);
    TransmissionClearAll();
    TriggerExecute(gt__1BAttackSkeleton1Unhighlight, true, false);
    while (!((gv__1B_AttackSkeleton1ObjectiveCreated == true))) {
        Wait(0.125, c_timeGame);
    }
    TriggerExecute(gt_ObjectiveKilltheUndeadComplete, true, false);
    Wait(2.0, c_timeReal);
    TriggerExecute(gt__1BAttackMoreSkeletonsQ, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1BAttackSkeleton1Dies_Init () {
    gt__1BAttackSkeleton1Dies = TriggerCreate("gt__1BAttackSkeleton1Dies_Func");
    TriggerAddEventUnitDied(gt__1BAttackSkeleton1Dies, UnitRefFromVariable("gv__1B_AttackSkeleton1"));
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1B - Attack More Skeletons Q
//--------------------------------------------------------------------------------------------------
bool gt__1BAttackMoreSkeletonsQ_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerEnable(gt__1BAttackMoreSkeletonsAAttacked, true);
    TriggerEnable(gt__1BAttackMoreSkeletonsCAttacked, true);
    TriggerEnable(gt__1BAMoveEnemiesAttacked, true);
    TriggerEnable(gt__1BAttackMoreSkeletonsDied, true);
    TriggerQueueEnter();
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
    libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00476", c_transmissionDurationAdd, 0.0, false, 1, 0);
    TransmissionWait(TransmissionLastSent(), 1.0);
    DialogControlSetVisible(libUIUI_gv_uIGameUIHandles.lv_minimapPanel, PlayerGroupAll(), true);
    Wait(0.5, c_timeGame);
    libNtve_gf_CreatePingFacingAngle(PlayerGroupAll(), "PingObjective", RegionGetCenter(RegionFromId(14)), ColorWithAlpha(100.00, 0.00, 0.00, 0.00), 0.0, 270.0);
    gv__1B_AttackMoreSkeletonsPingA = PingLastCreated();
    PingSetTooltip(PingLastCreated(), StringExternal("Param/Value/A8121FE5"));
    libNtve_gf_CreatePingFacingAngle(PlayerGroupAll(), "PingObjective", RegionGetCenter(RegionFromId(15)), ColorWithAlpha(100.00, 0.00, 0.00, 0.00), 0.0, 270.0);
    gv__1B_AttackMoreSkeletonsPingB = PingLastCreated();
    PingSetTooltip(PingLastCreated(), StringExternal("Param/Value/6343841D"));
    libNtve_gf_CreatePingFacingAngle(PlayerGroupAll(), "PingObjective", RegionGetCenter(RegionFromId(33)), ColorWithAlpha(100.00, 0.00, 0.00, 0.00), 0.0, 270.0);
    gv__1B_AttackMoreSkeletonsPingC = PingLastCreated();
    PingSetTooltip(PingLastCreated(), StringExternal("Param/Value/B6B34685"));
    TriggerExecute(gt__1BMinimapPulse, true, false);
    TransmissionWait(TransmissionLastSent(), 0.0);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
    Wait(1.0, c_timeGame);
    TriggerExecute(gt_ObjectiveKillMoreUndeadCreate, true, true);
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1BAttackMoreSkeletonsQ_Init () {
    gt__1BAttackMoreSkeletonsQ = TriggerCreate("gt__1BAttackMoreSkeletonsQ_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1B - Minimap Pulse
//--------------------------------------------------------------------------------------------------
bool gt__1BMinimapPulse_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    libNtve_gf_DisplayScreenImage(1, "Assets\\Textures\\tutorial_minimap_glow.dds", c_triggerBlendModeAdd, 484, 340, c_anchorBottomRight, 0, 0);
    libNtve_gf_PulseScreenImage(1, 1.75, 100.0, 0.0);
    Wait((1.75 * 6.0), c_timeGame);
    libNtve_gf_StopPulsingScreenImage(1);
    libNtve_gf_HideScreenImage(false, 1);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1BMinimapPulse_Init () {
    gt__1BMinimapPulse = TriggerCreate("gt__1BMinimapPulse_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1B - Attack More Skeletons A Attacked
//--------------------------------------------------------------------------------------------------
bool gt__1BAttackMoreSkeletonsAAttacked_Func (bool testConds, bool runActions) {
    // Variable Declarations
    point lv_oldLoc;

    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((EventUnitTarget() == gv_hERO_Raynor))) {
            return false;
        }

        if (!((UnitGroupHasUnit(gv__1B_AttackMoreSkeletonsA, EventUnit()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    while (true) {
        if ((libNtve_gf_UnitGroupIsDead(gv__1B_AttackMoreSkeletonsA) == true)) {
            return true;
        }
        else {
        }
        libNtve_gf_MakeUnitInvulnerable(gv_hERO_Raynor, false);
        UnitGroupLoopBegin(gv__1B_AttackMoreSkeletonsA);
        for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
            if ((UnitGroupLoopCurrent() != gv__1B_GlobeDroppingUnit1)) {
                UnitIssueOrder(UnitGroupLoopCurrent(), OrderTargetingUnit(AbilityCommand("attack", 0), gv_hERO_Raynor), c_orderQueueReplace);
            }
            else {
            }
        }
        UnitGroupLoopEnd();
        Wait(0.5, c_timeGame);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1BAttackMoreSkeletonsAAttacked_Init () {
    gt__1BAttackMoreSkeletonsAAttacked = TriggerCreate("gt__1BAttackMoreSkeletonsAAttacked_Func");
    TriggerEnable(gt__1BAttackMoreSkeletonsAAttacked, false);
    TriggerAddEventUnitAttacked2(gt__1BAttackMoreSkeletonsAAttacked, null, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1B - Attack More Skeletons Died
//--------------------------------------------------------------------------------------------------
bool gt__1BAttackMoreSkeletonsDied_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((UnitGroupHasUnit(gv__1B_AttackMoreSkeletonsAll, EventUnit()) == true))) {
            return false;
        }
    }

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

    Wait(0.125, c_timeGame);
    TriggerExecute(gt_ObjectiveKillMoreUndeadUpdate, true, false);
    if ((libNtve_gf_UnitGroupIsDead(gv__1B_AttackMoreSkeletonsA) == true) && (gv__1B_AttackMoreSkeletonsPingA != c_invalidPingId)) {
        PingDestroy(gv__1B_AttackMoreSkeletonsPingA);
        gv__1B_AttackMoreSkeletonsPingA = c_invalidPingId;
    }
    else {
    }
    if ((libNtve_gf_UnitGroupIsDead(gv__1B_AttackMoreSkeletonsB) == true) && (gv__1B_AttackMoreSkeletonsPingB != c_invalidPingId)) {
        PingDestroy(gv__1B_AttackMoreSkeletonsPingB);
        gv__1B_AttackMoreSkeletonsPingB = c_invalidPingId;
    }
    else {
    }
    if ((libNtve_gf_UnitGroupIsDead(gv__1B_AttackMoreSkeletonsC) == true) && (gv__1B_AttackMoreSkeletonsPingC != c_invalidPingId)) {
        PingDestroy(gv__1B_AttackMoreSkeletonsPingC);
        gv__1B_AttackMoreSkeletonsPingC = c_invalidPingId;
    }
    else {
    }
    if ((libNtve_gf_UnitGroupIsDead(gv__1B_AttackMoreSkeletonsAll) == true)) {
        TriggerEnable(TriggerGetCurrent(), false);
        libNtve_gf_MakeUnitInvulnerable(gv_hERO_Raynor, true);
        TriggerExecute(gt_ObjectiveKillMoreUndeadComplete, true, false);
        Wait(3.0, c_timeReal);
        TriggerExecute(gt__1CPenRoundQ, true, false);
    }
    else {
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1BAttackMoreSkeletonsDied_Init () {
    gt__1BAttackMoreSkeletonsDied = TriggerCreate("gt__1BAttackMoreSkeletonsDied_Func");
    TriggerEnable(gt__1BAttackMoreSkeletonsDied, false);
    TriggerAddEventUnitDied(gt__1BAttackMoreSkeletonsDied, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1B - Attack More Skeletons C Attacked
//--------------------------------------------------------------------------------------------------
bool gt__1BAttackMoreSkeletonsCAttacked_Func (bool testConds, bool runActions) {
    // Variable Declarations
    point lv_oldLoc;
    int lv_index;

    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((EventUnitTarget() == gv_hERO_Raynor))) {
            return false;
        }

        if (!((UnitGroupHasUnit(gv__1B_AttackMoreSkeletonsC, EventUnit()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    while (true) {
        if ((libNtve_gf_UnitGroupIsDead(gv__1B_AttackMoreSkeletonsC) == true)) {
            break;
        }
        else {
        }
        libNtve_gf_MakeUnitInvulnerable(gv_hERO_Raynor, false);
        UnitGroupIssueOrder(gv__1B_AttackMoreSkeletonsC, OrderTargetingUnit(AbilityCommand("attack", 0), gv_hERO_Raynor), c_orderQueueReplace);
        Wait(0.5, c_timeGame);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1BAttackMoreSkeletonsCAttacked_Init () {
    gt__1BAttackMoreSkeletonsCAttacked = TriggerCreate("gt__1BAttackMoreSkeletonsCAttacked_Func");
    TriggerEnable(gt__1BAttackMoreSkeletonsCAttacked, false);
    TriggerAddEventUnitAttacked2(gt__1BAttackMoreSkeletonsCAttacked, null, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1B - AMove Enemies Approached Q
//--------------------------------------------------------------------------------------------------
bool gt__1BAMoveEnemiesApproachedQ_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerEnable(TriggerGetCurrent(), false);
    UnitIssueOrder(gv_hERO_Raynor, Order(AbilityCommand("move", 2)), c_orderQueueReplace);
    libNtve_gf_MakeUnitUncommandable(gv_hERO_Raynor, true);
    UnitAbilityEnable(gv_hERO_Raynor, "move", false);
    UnitAbilityEnable(gv_hERO_Raynor, "attack", false);
    TriggerEnable(gt__1BAMoveAttackOrderIssued, true);
    TriggerQueueEnter();
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
    libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00226", c_transmissionDurationAdd, 0.0, false, 2, 0);
    TransmissionWait(TransmissionLastSent(), 1.0);
    libNtve_gf_MakeUnitUncommandable(gv_hERO_Raynor, false);
    UnitAbilityEnable(gv_hERO_Raynor, "attack", true);
    if ((gv__1B_AMoveEnemiesAttacked == false)) {
        TextExpressionSetToken("Param/Expression/41791700", "A", StringExternal("Param/Value/9EA633C8"));
        TextExpressionSetToken("Param/Expression/41791700", "B", libStEx_gf_HotkeyProfile_MouseButtonImageStringTag(1, libStEx_gv_sEC_MouseButtonWidth, libStEx_gv_sEC_MouseButtonHeight));
        libStEx_gf_DisplayHintMessage(TextExpressionAssemble("Param/Expression/41791700"), true, 1.5);
    }
    else {
    }
    TransmissionWait(TransmissionLastSent(), 0.0);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
    if ((gv__1B_AMoveEnemiesAttacked == false)) {
        TriggerExecute(gt__1BAMoveHighlight, true, false);
    }
    else {
    }
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1BAMoveEnemiesApproachedQ_Init () {
    gt__1BAMoveEnemiesApproachedQ = TriggerCreate("gt__1BAMoveEnemiesApproachedQ_Func");
    TriggerAddEventUnitRegion(gt__1BAMoveEnemiesApproachedQ, UnitRefFromVariable("gv_hERO_Raynor"), RegionFromId(47), true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1B - AMove Attack Order Issued
//--------------------------------------------------------------------------------------------------
bool gt__1BAMoveAttackOrderIssued_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    if ((OrderGetTargetPoint(EventUnitOrder()) != null) && (DistanceBetweenPoints(OrderGetTargetPoint(EventUnitOrder()), PointFromId(1663)) <= 6.0)) {
        TriggerEnable(TriggerGetCurrent(), false);
        UnitAbilityEnable(gv_hERO_Raynor, "move", true);
    }
    else {
        UnitIssueOrder(gv_hERO_Raynor, Order(AbilityCommand("stop", 0)), c_orderQueueReplace);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1BAMoveAttackOrderIssued_Init () {
    gt__1BAMoveAttackOrderIssued = TriggerCreate("gt__1BAMoveAttackOrderIssued_Func");
    TriggerEnable(gt__1BAMoveAttackOrderIssued, false);
    TriggerAddEventUnitOrder(gt__1BAMoveAttackOrderIssued, UnitRefFromVariable("gv_hERO_Raynor"), AbilityCommand("attack", 0));
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1B - AMove Highlight
//--------------------------------------------------------------------------------------------------
bool gt__1BAMoveHighlight_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }

        if (!((gv__1B_AMoveEnemiesAttacked == false))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    libCore_gf_CreateReticleEffectAndTextTagAtPoint(2, 2, StringExternal("Param/Value/57C0CE1D"), PointFromId(1663));
    gv__1B_AMoveReticle = libNtve_gf_ActorLastCreated();
    gv__1B_AMoveTextTag = TextTagLastCreated();
    TextTagSetFogVisibility(gv__1B_AMoveTextTag, c_visTypeMask);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1BAMoveHighlight_Init () {
    gt__1BAMoveHighlight = TriggerCreate("gt__1BAMoveHighlight_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1B - AMove Enemies Attacked
//--------------------------------------------------------------------------------------------------
bool gt__1BAMoveEnemiesAttacked_Func (bool testConds, bool runActions) {
    // Variable Declarations
    point lv_oldLoc;
    int lv_index;

    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((EventUnitTarget() == gv_hERO_Raynor))) {
            return false;
        }

        if (!((UnitGroupHasUnit(gv__1B_AttackMoreSkeletonsB, EventUnit()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerEnable(gt__1BAMoveAttackOrderIssued, false);
    gv__1B_AMoveEnemiesAttacked = true;
    libStEx_gf_ClearHintMessage();
    libNtve_gf_KillModel(gv__1B_AMoveReticle);
    gv__1B_AMoveReticle = null;
    TextTagDestroy(gv__1B_AMoveTextTag);
    gv__1B_AMoveTextTag = c_textTagNone;
    while (true) {
        if ((libNtve_gf_UnitGroupIsDead(gv__1B_AttackMoreSkeletonsB) == true)) {
            break;
        }
        else {
        }
        libNtve_gf_MakeUnitInvulnerable(gv_hERO_Raynor, false);
        UnitGroupLoopBegin(gv__1B_AttackMoreSkeletonsB);
        for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
            if ((UnitGroupLoopCurrent() != gv__1B_GlobeDroppingUnit2)) {
                UnitIssueOrder(UnitGroupLoopCurrent(), OrderTargetingUnit(AbilityCommand("attack", 0), gv_hERO_Raynor), c_orderQueueReplace);
            }
            else {
            }
        }
        UnitGroupLoopEnd();
        Wait(0.5, c_timeGame);
        lv_index += 1;
        if ((lv_index == 6)) {
            TriggerExecute(gt__1BAttackSkeletonsWhatAreTheseMonstersQ, true, false);
        }
        else {
        }
    }
    TriggerExecute(gt__1BAttackSkeletonsWhatAreTheseMonstersQ, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1BAMoveEnemiesAttacked_Init () {
    gt__1BAMoveEnemiesAttacked = TriggerCreate("gt__1BAMoveEnemiesAttacked_Func");
    TriggerEnable(gt__1BAMoveEnemiesAttacked, false);
    TriggerAddEventUnitAttacked2(gt__1BAMoveEnemiesAttacked, null, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1B - Attack Skeletons - What Are These Monsters Q
//--------------------------------------------------------------------------------------------------
bool gt__1BAttackSkeletonsWhatAreTheseMonstersQ_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerQueueEnter();
    Wait(3.0, c_timeGame);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
    libCore_gf_SendTransmissionCampaign(gv_hERO_Raynor, "TutorialVO|Line00474", c_transmissionDurationAdd, 0.0, true, 1, 0);
    libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00475", c_transmissionDurationAdd, 0.0, true, 1, 0);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1BAttackSkeletonsWhatAreTheseMonstersQ_Init () {
    gt__1BAttackSkeletonsWhatAreTheseMonstersQ = TriggerCreate("gt__1BAttackSkeletonsWhatAreTheseMonstersQ_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1B - Globe Run 1
//--------------------------------------------------------------------------------------------------
bool gt__1BGlobeRun1_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((EventUnitTarget() == gv_hERO_Raynor))) {
            return false;
        }

        if (!((UnitGroupCount(gv__1B_AttackMoreSkeletonsA, c_unitCountAlive) == 1))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    gv__1B_GlobeDroppingUnit1 = EventUnit();
    Wait(0.7, c_timeGame);
    UnitIssueOrder(EventUnit(), OrderTargetingPoint(AbilityCommand("move", 0), libCore_gf_PointStoredForUnit(EventUnit(), 1)), c_orderQueueReplace);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1BGlobeRun1_Init () {
    gt__1BGlobeRun1 = TriggerCreate("gt__1BGlobeRun1_Func");
    TriggerAddEventUnitAttacked2(gt__1BGlobeRun1, UnitRefFromUnit(UnitFromId(33)), null);
    TriggerAddEventUnitAttacked2(gt__1BGlobeRun1, UnitRefFromUnit(UnitFromId(1228)), null);
    TriggerAddEventUnitAttacked2(gt__1BGlobeRun1, UnitRefFromUnit(UnitFromId(32)), null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1B - Globe Run 2
//--------------------------------------------------------------------------------------------------
bool gt__1BGlobeRun2_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((EventUnitTarget() == gv_hERO_Raynor))) {
            return false;
        }

        if (!((UnitGroupCount(gv__1B_AttackMoreSkeletonsB, c_unitCountAlive) == 1))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    gv__1B_GlobeDroppingUnit2 = EventUnit();
    Wait(0.7, c_timeGame);
    UnitIssueOrder(EventUnit(), OrderTargetingPoint(AbilityCommand("move", 0), libCore_gf_PointStoredForUnit(EventUnit(), 1)), c_orderQueueReplace);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1BGlobeRun2_Init () {
    gt__1BGlobeRun2 = TriggerCreate("gt__1BGlobeRun2_Func");
    TriggerAddEventUnitAttacked2(gt__1BGlobeRun2, UnitRefFromUnit(UnitFromId(44)), null);
    TriggerAddEventUnitAttacked2(gt__1BGlobeRun2, UnitRefFromUnit(UnitFromId(42)), null);
    TriggerAddEventUnitAttacked2(gt__1BGlobeRun2, UnitRefFromUnit(UnitFromId(43)), null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1B - Drop Globe 1
//--------------------------------------------------------------------------------------------------
bool gt__1BDropGlobe1_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerEnable(TriggerGetCurrent(), false);
    UnitIssueOrder(gv_hERO_Raynor, Order(AbilityCommand("stop", 0)), c_orderQueueReplace);
    gf__1BSpawnGlobeQ(UnitGetPosition(EventUnit()));
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1BDropGlobe1_Init () {
    gt__1BDropGlobe1 = TriggerCreate("gt__1BDropGlobe1_Func");
    TriggerAddEventUnitDied(gt__1BDropGlobe1, UnitRefFromVariable("gv__1B_GlobeDroppingUnit1"));
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1B - Drop Globe 2
//--------------------------------------------------------------------------------------------------
bool gt__1BDropGlobe2_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerEnable(TriggerGetCurrent(), false);
    gf__1BSpawnGlobeQ(UnitGetPosition(EventUnit()));
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1BDropGlobe2_Init () {
    gt__1BDropGlobe2 = TriggerCreate("gt__1BDropGlobe2_Func");
    TriggerAddEventUnitDied(gt__1BDropGlobe2, UnitRefFromVariable("gv__1B_GlobeDroppingUnit2"));
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1B - Globe Picked Up Q
//--------------------------------------------------------------------------------------------------
bool gt__1BGlobePickedUpQ_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerEnable(TriggerGetCurrent(), false);
    libNtve_gf_KillModel(gv__1B_GlobeReticle);
    TextTagDestroy(gv__1B_GlobeTextTag);
    if ((gv__1B_GlobeExplained == false)) {
        gv__1B_GlobeExplained = true;
        TriggerQueueEnter();
        libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
        libCore_gf_SendTransmissionCampaign(gv_hERO_Raynor, "TutorialVO|Line00280", c_transmissionDurationAdd, 0.0, true, 2, 0);
        libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00258", c_transmissionDurationAdd, 0.0, true, 2, 0);
        libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
        TriggerQueueExit();
    }
    else {
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1BGlobePickedUpQ_Init () {
    gt__1BGlobePickedUpQ = TriggerCreate("gt__1BGlobePickedUpQ_Func");
    TriggerEnable(gt__1BGlobePickedUpQ, false);
    TriggerAddEventUnitDied(gt__1BGlobePickedUpQ, UnitRefFromVariable("gv__1B_Globe"));
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1C - PenRound Prep
//--------------------------------------------------------------------------------------------------
bool gt__1CPenRoundPrep_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerEnable(gt__1BAMoveAttackOrderIssued, false);
    DialogControlHookupStandard(c_triggerControlTypePanel, "UIContainer/ConsoleUIContainer/HeroCommandCardPanelFrame/AbilitiesBarGlass");
    DialogControlSetVisible(DialogControlLastCreated(), PlayerGroupAll(), true);
    UnitAbilityShow(gv_hERO_Raynor, "RaynorPenetratingRound", true);
    UnitIssueOrder(gv_hERO_Raynor, Order(AbilityCommand("move", 2)), c_orderQueueReplace);
    UnitAbilityEnable(gv_hERO_Raynor, "move", false);
    UnitAbilityEnable(gv_hERO_Raynor, "attack", false);
    libNtve_gf_MakeUnitUncommandable(gv_hERO_Raynor, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1CPenRoundPrep_Init () {
    gt__1CPenRoundPrep = TriggerCreate("gt__1CPenRoundPrep_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1C - PenRound Q
//--------------------------------------------------------------------------------------------------
bool gt__1CPenRoundQ_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerEnable(gt__1CZombieDies, true);
    TriggerExecute(gt_MidAbilityQ, true, true);
    UnitGroupIssueOrder(gv__1C_Zombies1, Order(AbilityCommand("move", 2)), c_orderQueueReplace);
    TriggerEnable(gt__1CPenRoundHitQ, true);
    TriggerEnable(gt__1CPenRoundTargetingModeOn, true);
    TriggerEnable(gt__1CZombieAttacked, true);
    Wait(2.0, c_timeGame);
    TriggerQueueEnter();
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
    libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00283", c_transmissionDurationAdd, 0.0, false, 1, 0);
    TransmissionWait(TransmissionLastSent(), 3.0);
    libStEx_gf_HighlightCommandButton(true, 1);
    UISetButtonHighlighted(PlayerGroupAll(), AbilityCommand("RaynorPenetratingRound", 0), true);
    libNtve_gf_UnitRemoveCooldown(gv_hERO_Raynor, "Abil/RaynorPenetratingRound");
    TransmissionWait(TransmissionLastSent(), 0.0);
    Wait(1.0, c_timeGame);
    UnitGroupLoopBegin(gv__1C_Zombies1);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        gf__1CPenRoundPrepareSkeleton(UnitGroupLoopCurrent());
        Wait(RandomFixed(0.1, 0.2), c_timeGame);
    }
    UnitGroupLoopEnd();
    libNtve_gf_UnitRemoveCooldown(gv_hERO_Raynor, "Abil/RaynorPenetratingRound");
    TriggerEnable(gt__1CPenRoundMissedQ, true);
    Wait(1.0, c_timeGame);
    if ((gv__1C_PenRoundHit == false)) {
        VisRevealArea(gv_pLAYER_01_USER, RegionFromId(23), 15.0, false);
        libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00284", c_transmissionDurationAdd, 0.0, false, 2, 0);
        TransmissionWait(TransmissionLastSent(), 2.0);
        if ((gv__1C_PenRoundHit == false)) {
            libCore_gf_AttachReticleEffectAndTextTagOnUnit(2, 2, null, UnitFromId(1827), "Ref_Center");
            gv__1C_PenRoundReticle = libNtve_gf_ActorLastCreated();
            TextExpressionSetToken("Param/Expression/8876702F", "A", StringExternal("Param/Value/2C733A6D"));
            TextExpressionSetToken("Param/Expression/8876702F", "B", libStEx_gf_HotkeyProfile_MouseButtonImageStringTag(1, libStEx_gv_sEC_MouseButtonWidth, libStEx_gv_sEC_MouseButtonHeight));
            libStEx_gf_DisplayHintMessage(TextExpressionAssemble("Param/Expression/8876702F"), true, 1.5);
        }
        else {
        }
        TransmissionWait(TransmissionLastSent(), 0.0);
        if ((gv__1C_PenRoundHit == false)) {
            libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00440", c_transmissionDurationAdd, 0.0, true, 2, 0);
        }
        else {
        }
    }
    else {
    }
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
    TriggerExecute(gt_ObjectiveKillZombiesCreate, true, false);
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1CPenRoundQ_Init () {
    gt__1CPenRoundQ = TriggerCreate("gt__1CPenRoundQ_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1C - PenRound Hit Q
//--------------------------------------------------------------------------------------------------
bool gt__1CPenRoundHitQ_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerEnable(TriggerGetCurrent(), false);
    gv__1C_PenRoundHit = true;
    UnitGroupLoopBegin(gv__1C_Zombies1);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        UnitIssueOrder(UnitGroupLoopCurrent(), OrderTargetingUnit(AbilityCommand("attack", 0), gv_hERO_Raynor), c_orderQueueReplace);
    }
    UnitGroupLoopEnd();
    TransmissionClearAll();
    libStEx_gf_ClearHintMessage();
    TriggerExecute(gt_AddReferenceCardPenetratingRound, true, false);
    if ((gv__1C_PenRoundReticle != null)) {
        libNtve_gf_KillModel(gv__1C_PenRoundReticle);
        gv__1C_PenRoundReticle = null;
    }
    else {
    }
    if ((gv__1C_PenRoundTextTag != c_textTagNone)) {
        TextTagDestroy(gv__1C_PenRoundTextTag);
        gv__1C_PenRoundTextTag = c_textTagNone;
    }
    else {
    }
    UISetButtonHighlighted(PlayerGroupAll(), AbilityCommand("RaynorPenetratingRound", 0), false);
    libStEx_gf_HighlightCommandButton(false, 1);
    UnitAbilityEnable(gv_hERO_Raynor, "attack", true);
    UnitAbilityEnable(gv_hERO_Raynor, "move", true);
    TriggerQueueEnter();
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
    libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00239", c_transmissionDurationAdd, 0.0, true, 2, 0);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1CPenRoundHitQ_Init () {
    gt__1CPenRoundHitQ = TriggerCreate("gt__1CPenRoundHitQ_Func");
    TriggerEnable(gt__1CPenRoundHitQ, false);
    TriggerAddEventUnitDamaged(gt__1CPenRoundHitQ, UnitRefFromUnit(UnitFromId(1827)), c_unitDamageTypeAny, c_unitDamageEither, "PenetratingRoundDamage");
    TriggerAddEventUnitDamaged(gt__1CPenRoundHitQ, UnitRefFromUnit(UnitFromId(1828)), c_unitDamageTypeAny, c_unitDamageEither, "PenetratingRoundDamage");
    TriggerAddEventUnitDamaged(gt__1CPenRoundHitQ, UnitRefFromUnit(UnitFromId(279)), c_unitDamageTypeAny, c_unitDamageEither, "PenetratingRoundDamage");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1C - PenRound Targeting Mode On
//--------------------------------------------------------------------------------------------------
bool gt__1CPenRoundTargetingModeOn_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerEnable(TriggerGetCurrent(), false);
    gv__1C_PenRoundCasted = false;
    TriggerEnable(gt__1CPenRoundTargetingModeOff, true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1CPenRoundTargetingModeOn_Init () {
    gt__1CPenRoundTargetingModeOn = TriggerCreate("gt__1CPenRoundTargetingModeOn_Func");
    TriggerEnable(gt__1CPenRoundTargetingModeOn, false);
    TriggerAddEventTargetModeUpdate(gt__1CPenRoundTargetingModeOn, gv_pLAYER_01_USER, AbilityCommand("RaynorPenetratingRound", 0), c_targetModeStateOn);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1C - PenRound Targeting Mode Off
//--------------------------------------------------------------------------------------------------
bool gt__1CPenRoundTargetingModeOff_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerEnable(TriggerGetCurrent(), false);
    Wait(1.0, c_timeGame);
    if ((gv__1C_PenRoundCasted == false)) {
        TriggerQueueEnter();
        libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
        libCore_gf_SendTransmissionCampaign(null, "TutorialVO|Line00460", c_transmissionDurationAdd, 0.0, true, 1, 0);
        libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
        TriggerQueueExit();
    }
    else {
    }
    TriggerEnable(gt__1CPenRoundTargetingModeOn, true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1CPenRoundTargetingModeOff_Init () {
    gt__1CPenRoundTargetingModeOff = TriggerCreate("gt__1CPenRoundTargetingModeOff_Func");
    TriggerEnable(gt__1CPenRoundTargetingModeOff, false);
    TriggerAddEventTargetModeUpdate(gt__1CPenRoundTargetingModeOff, gv_pLAYER_01_USER, AbilityCommand("RaynorPenetratingRound", 0), c_targetModeStateOff);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1C - PenRound Casted
//--------------------------------------------------------------------------------------------------
bool gt__1CPenRoundCasted_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    gv__1C_PenRoundCasted = true;
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1CPenRoundCasted_Init () {
    gt__1CPenRoundCasted = TriggerCreate("gt__1CPenRoundCasted_Func");
    TriggerAddEventUnitAbility(gt__1CPenRoundCasted, UnitRefFromVariable("gv_hERO_Raynor"), AbilityCommand("RaynorPenetratingRound", 0), c_abilEffectStageCast, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1C - PenRound Missed Q
//--------------------------------------------------------------------------------------------------
bool gt__1CPenRoundMissedQ_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((gv__1C_PenRoundHit == false))) {
            return false;
        }
    }

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

    gv__1C_PenRoundCasted = true;
    Wait(1.0, c_timeGame);
    if ((gv__1C_PenRoundHit == true)) {
        return true;
    }
    else {
    }
    TriggerQueueEnter();
    if ((gv__1C_PenRoundHit == true)) {
        return true;
    }
    else {
    }
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
    libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00285", c_transmissionDurationAdd, 0.0, false, 2, 0);
    Wait(2.0, c_timeReal);
    libNtve_gf_UnitRemoveCooldown(gv_hERO_Raynor, "Abil/RaynorPenetratingRound");
    TransmissionWait(TransmissionLastSent(), 0.0);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1CPenRoundMissedQ_Init () {
    gt__1CPenRoundMissedQ = TriggerCreate("gt__1CPenRoundMissedQ_Func");
    TriggerEnable(gt__1CPenRoundMissedQ, false);
    TriggerAddEventUnitAbility(gt__1CPenRoundMissedQ, UnitRefFromVariable("gv_hERO_Raynor"), AbilityCommand("RaynorPenetratingRound", 0), c_abilEffectStageCast, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1C - PenRound Again Q 
//--------------------------------------------------------------------------------------------------
bool gt__1CPenRoundAgainQ_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    gv__1C_PenRoundHit = false;
    TriggerEnable(gt__1CPenRoundAgainHitQ, true);
    TriggerEnable(gt__1CPenRoundTargetingModeOn, true);
    TriggerEnable(gt__1CPenRoundMissedQ, true);
    TriggerExecute(gt__1CPenRoundAgainRaynorStop, true, false);
    UnitAbilityEnable(gv_hERO_Raynor, "attack", false);
    libNtve_gf_MakeUnitUncommandable(gv_hERO_Raynor, false);
    gf__1CPenRoundPrepareSkeletonPos(UnitFromId(1837), UnitFromId(1837), 0.0, 0);
    Wait(0.0625, c_timeGame);
    gf__1CPenRoundPrepareSkeletonPos(UnitFromId(282), UnitFromId(1837), 1.6, -15.0);
    Wait(0.0625, c_timeGame);
    gf__1CPenRoundPrepareSkeletonPos(UnitFromId(1880), UnitFromId(1837), 3.0, 10.0);
    TriggerQueueEnter();
    if ((gv__1C_PenRoundHit == false)) {
        libStEx_gf_HighlightCommandButton(true, 1);
        libNtve_gf_UnitRemoveCooldown(gv_hERO_Raynor, "Abil/RaynorPenetratingRound");
    }
    else {
    }
    Wait(1.0, c_timeGame);
    if ((gv__1C_PenRoundHit == false)) {
        libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
        libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00442", c_transmissionDurationAdd, 0.0, true, 1, 0);
        libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
    }
    else {
    }
    if ((gv__1C_PenRoundHit == false)) {
        libCore_gf_AttachReticleEffectAndTextTagOnUnit(2, 2, null, UnitFromId(1837), "Ref_Center");
        TextExpressionSetToken("Param/Expression/7BE0A43B", "A", StringExternal("Param/Value/ECB9F000"));
        TextExpressionSetToken("Param/Expression/7BE0A43B", "B", libStEx_gf_HotkeyProfile_MouseButtonImageStringTag(1, libStEx_gv_sEC_MouseButtonWidth, libStEx_gv_sEC_MouseButtonHeight));
        libStEx_gf_DisplayHintMessage(TextExpressionAssemble("Param/Expression/7BE0A43B"), true, 1.5);
        gv__1C_PenRoundReticle = libNtve_gf_ActorLastCreated();
    }
    else {
    }
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1CPenRoundAgainQ_Init () {
    gt__1CPenRoundAgainQ = TriggerCreate("gt__1CPenRoundAgainQ_Func");
    TriggerAddEventUnitRange(gt__1CPenRoundAgainQ, UnitRefFromVariable("gv_hERO_Raynor"), UnitFromId(1837), 9.0, true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1C - PenRound Again Raynor Stop
//--------------------------------------------------------------------------------------------------
bool gt__1CPenRoundAgainRaynorStop_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    libNtve_gf_MakeUnitUncommandable(gv_hERO_Raynor, true);
    UnitIssueOrder(gv_hERO_Raynor, OrderTargetingPoint(AbilityCommand("move", 0), PointWithOffsetPolar(UnitGetPosition(UnitFromId(1837)), 7.0, AngleBetweenPoints(UnitGetPosition(UnitFromId(1837)), UnitGetPosition(gv_hERO_Raynor)))), c_orderQueueReplace);
    while (!(((DistanceBetweenPoints(UnitGetPosition(gv_hERO_Raynor), UnitGetPosition(UnitFromId(1837))) <= 7.0) || (gv__1C_PenRoundHit == true)))) {
        Wait(0.125, c_timeGame);
    }
    if ((gv__1C_PenRoundHit == false)) {
        UnitIssueOrder(gv_hERO_Raynor, Order(AbilityCommand("move", 2)), c_orderQueueReplace);
        UnitAbilityEnable(gv_hERO_Raynor, "move", false);
    }
    else {
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1CPenRoundAgainRaynorStop_Init () {
    gt__1CPenRoundAgainRaynorStop = TriggerCreate("gt__1CPenRoundAgainRaynorStop_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1C - PenRound Again Hit Q
//--------------------------------------------------------------------------------------------------
bool gt__1CPenRoundAgainHitQ_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerEnable(TriggerGetCurrent(), false);
    gv__1C_PenRoundHit = true;
    UnitGroupLoopBegin(gv__1C_Zombies2);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        UnitIssueOrder(UnitGroupLoopCurrent(), OrderTargetingUnit(AbilityCommand("attack", 0), gv_hERO_Raynor), c_orderQueueReplace);
    }
    UnitGroupLoopEnd();
    TransmissionClearAll();
    libStEx_gf_ClearHintMessage();
    if ((gv__1C_PenRoundReticle != null)) {
        libNtve_gf_KillModel(gv__1C_PenRoundReticle);
        gv__1C_PenRoundReticle = null;
    }
    else {
    }
    if ((gv__1C_PenRoundTextTag != c_textTagNone)) {
        TextTagDestroy(gv__1C_PenRoundTextTag);
        gv__1C_PenRoundTextTag = c_textTagNone;
    }
    else {
    }
    libStEx_gf_HighlightCommandButton(false, 1);
    UnitAbilityEnable(gv_hERO_Raynor, "attack", true);
    UnitAbilityEnable(gv_hERO_Raynor, "move", true);
    TriggerQueueEnter();
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
    libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00353", c_transmissionDurationAdd, 0.0, true, 2, 0);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1CPenRoundAgainHitQ_Init () {
    gt__1CPenRoundAgainHitQ = TriggerCreate("gt__1CPenRoundAgainHitQ_Func");
    TriggerEnable(gt__1CPenRoundAgainHitQ, false);
    TriggerAddEventUnitDamaged(gt__1CPenRoundAgainHitQ, UnitRefFromUnit(UnitFromId(1837)), c_unitDamageTypeAny, c_unitDamageEither, "PenetratingRoundDamage");
    TriggerAddEventUnitDamaged(gt__1CPenRoundAgainHitQ, UnitRefFromUnit(UnitFromId(282)), c_unitDamageTypeAny, c_unitDamageEither, "PenetratingRoundDamage");
    TriggerAddEventUnitDamaged(gt__1CPenRoundAgainHitQ, UnitRefFromUnit(UnitFromId(1880)), c_unitDamageTypeAny, c_unitDamageEither, "PenetratingRoundDamage");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1C - PenRound Again Again Q
//--------------------------------------------------------------------------------------------------
bool gt__1CPenRoundAgainAgainQ_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    gv__1C_PenRoundHit = false;
    TriggerEnable(gt__1CPenRoundAgainAgainHitQ, true);
    TriggerEnable(gt__1CPenRoundTargetingModeOn, true);
    TriggerEnable(gt__1CPenRoundMissedQ, true);
    TriggerExecute(gt__1CPenRoundAgainAgainRaynorStop, true, false);
    UnitAbilityEnable(gv_hERO_Raynor, "attack", false);
    libNtve_gf_MakeUnitUncommandable(gv_hERO_Raynor, false);
    gf__1CPenRoundPrepareSkeletonPos(UnitFromId(1882), UnitFromId(1882), 0.0, 0);
    Wait(0.0625, c_timeGame);
    gf__1CPenRoundPrepareSkeletonPos(UnitFromId(2158), UnitFromId(1882), 1.7, 18.0);
    Wait(0.0625, c_timeGame);
    gf__1CPenRoundPrepareSkeletonPos(UnitFromId(1881), UnitFromId(1882), 3.2, -10.0);
    TriggerQueueEnter();
    if ((gv__1C_PenRoundHit == false)) {
        libStEx_gf_HighlightCommandButton(true, 1);
        libNtve_gf_UnitRemoveCooldown(gv_hERO_Raynor, "Abil/RaynorPenetratingRound");
    }
    else {
    }
    Wait(1.0, c_timeGame);
    if ((gv__1C_PenRoundHit == false)) {
        libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
        libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00320", c_transmissionDurationAdd, 0.0, true, 1, 0);
        libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
    }
    else {
    }
    if ((gv__1C_PenRoundHit == false)) {
        libCore_gf_AttachReticleEffectAndTextTagOnUnit(2, 2, null, UnitFromId(1837), "Ref_Center");
        TextExpressionSetToken("Param/Expression/F52FD19F", "A", StringExternal("Param/Value/F451F4E0"));
        TextExpressionSetToken("Param/Expression/F52FD19F", "B", libStEx_gf_HotkeyProfile_MouseButtonImageStringTag(1, libStEx_gv_sEC_MouseButtonWidth, libStEx_gv_sEC_MouseButtonHeight));
        libStEx_gf_DisplayHintMessage(TextExpressionAssemble("Param/Expression/F52FD19F"), true, 1.5);
        gv__1C_PenRoundReticle = libNtve_gf_ActorLastCreated();
    }
    else {
    }
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1CPenRoundAgainAgainQ_Init () {
    gt__1CPenRoundAgainAgainQ = TriggerCreate("gt__1CPenRoundAgainAgainQ_Func");
    TriggerAddEventUnitRange(gt__1CPenRoundAgainAgainQ, UnitRefFromVariable("gv_hERO_Raynor"), UnitFromId(1882), 9.0, true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1C - PenRound Again Again Raynor Stop
//--------------------------------------------------------------------------------------------------
bool gt__1CPenRoundAgainAgainRaynorStop_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    libNtve_gf_MakeUnitUncommandable(gv_hERO_Raynor, true);
    UnitIssueOrder(gv_hERO_Raynor, OrderTargetingPoint(AbilityCommand("move", 0), PointWithOffsetPolar(UnitGetPosition(UnitFromId(1882)), 7.0, AngleBetweenPoints(UnitGetPosition(UnitFromId(1882)), UnitGetPosition(gv_hERO_Raynor)))), c_orderQueueReplace);
    while (!(((DistanceBetweenPoints(UnitGetPosition(gv_hERO_Raynor), UnitGetPosition(UnitFromId(1882))) <= 7.0) || (gv__1C_PenRoundHit == true)))) {
        Wait(0.125, c_timeGame);
    }
    if ((gv__1C_PenRoundHit == false)) {
        UnitIssueOrder(gv_hERO_Raynor, Order(AbilityCommand("move", 2)), c_orderQueueReplace);
        UnitAbilityEnable(gv_hERO_Raynor, "move", false);
    }
    else {
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1CPenRoundAgainAgainRaynorStop_Init () {
    gt__1CPenRoundAgainAgainRaynorStop = TriggerCreate("gt__1CPenRoundAgainAgainRaynorStop_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1C - PenRound Again Again Hit Q
//--------------------------------------------------------------------------------------------------
bool gt__1CPenRoundAgainAgainHitQ_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerEnable(TriggerGetCurrent(), false);
    gv__1C_PenRoundHit = true;
    UnitGroupLoopBegin(gv__1C_Zombies2);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        UnitIssueOrder(UnitGroupLoopCurrent(), OrderTargetingUnit(AbilityCommand("attack", 0), gv_hERO_Raynor), c_orderQueueReplace);
    }
    UnitGroupLoopEnd();
    TransmissionClearAll();
    libStEx_gf_ClearHintMessage();
    if ((gv__1C_PenRoundReticle != null)) {
        libNtve_gf_KillModel(gv__1C_PenRoundReticle);
        gv__1C_PenRoundReticle = null;
    }
    else {
    }
    if ((gv__1C_PenRoundTextTag != c_textTagNone)) {
        TextTagDestroy(gv__1C_PenRoundTextTag);
        gv__1C_PenRoundTextTag = c_textTagNone;
    }
    else {
    }
    libStEx_gf_HighlightCommandButton(false, 1);
    UnitAbilityEnable(gv_hERO_Raynor, "attack", true);
    UnitAbilityEnable(gv_hERO_Raynor, "move", true);
    TriggerQueueEnter();
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
    libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00354", c_transmissionDurationAdd, 0.0, true, 2, 0);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1CPenRoundAgainAgainHitQ_Init () {
    gt__1CPenRoundAgainAgainHitQ = TriggerCreate("gt__1CPenRoundAgainAgainHitQ_Func");
    TriggerEnable(gt__1CPenRoundAgainAgainHitQ, false);
    TriggerAddEventUnitDamaged(gt__1CPenRoundAgainAgainHitQ, UnitRefFromUnit(UnitFromId(1882)), c_unitDamageTypeAny, c_unitDamageEither, "PenetratingRoundDamage");
    TriggerAddEventUnitDamaged(gt__1CPenRoundAgainAgainHitQ, UnitRefFromUnit(UnitFromId(2158)), c_unitDamageTypeAny, c_unitDamageEither, "PenetratingRoundDamage");
    TriggerAddEventUnitDamaged(gt__1CPenRoundAgainAgainHitQ, UnitRefFromUnit(UnitFromId(1881)), c_unitDamageTypeAny, c_unitDamageEither, "PenetratingRoundDamage");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1C - Zombies Inspire Q
//--------------------------------------------------------------------------------------------------
bool gt__1CZombiesInspireQ_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }

        if (!((libNtve_gf_UnitGroupIsDead(gv__1C_Zombies1) == true))) {
            return false;
        }

        if (!((libNtve_gf_UnitGroupIsDead(gv__1C_Zombies2) == true))) {
            return false;
        }

        if (!((libNtve_gf_UnitGroupIsDead(gv__1C_Zombies3) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    Wait(1.5, c_timeGame);
    CinematicFade(false, 1.5, c_fadeStyleNormal, Color(0.00, 0.00, 0.00), 0.0, true);
    libNtve_gf_MakeUnitUncommandable(gv_hERO_Raynor, true);
    UnitSetPosition(gv_hERO_Raynor, PointFromId(1207), false);
    UnitIssueOrder(gv_hERO_Raynor, OrderTargetingPoint(AbilityCommand("move", 0), PointFromId(283)), c_orderQueueReplace);
    RegionPlayableMapSet(RegionFromId(2));
    CinematicFade(true, 1.0, c_fadeStyleNormal, Color(0.00, 0.00, 0.00), 0.0, true);
    UnitGroupLoopBegin(gv__1C_Zombies4);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        libNtve_gf_ShareVisionofUnit(UnitGroupLoopCurrent(), true, gv_pLAYER_01_USER);
        libNtve_gf_ShowHideUnit(UnitGroupLoopCurrent(), true);
    }
    UnitGroupLoopEnd();
    libStEx_gf_TurnCinematicCameraOnOff(gv_pLAYER_01_USER, true);
    Wait(1.0, c_timeGame);
    TriggerQueueEnter();
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
    libCore_gf_SendTransmissionCampaign(UnitFromId(285), "TutorialVO|Line00314", c_transmissionDurationAdd, 0.0, false, 1, 0);
    Wait(1.0, c_timeGame);
    CameraPan(gv_pLAYER_01_USER, CameraInfoGetTarget(CameraInfoFromId(2070)), 1.5, -1, 10.0, false);
    TransmissionWait(TransmissionLastSent(), 0.0);
    libCore_gf_SendTransmissionCampaign(gv_hERO_Raynor, "TutorialVO|Line00315", c_transmissionDurationAdd, 0.0, false, 1, 0);
    Wait(1.0, c_timeGame);
    CameraPan(gv_pLAYER_01_USER, UnitGetPosition(gv_hERO_Raynor), 1.0, -1, 10.0, false);
    TransmissionWait(TransmissionLastSent(), 0.0);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
    TriggerQueueExit();
    TriggerExecute(gt__1CInspireQ, true, false);
    libNtve_gf_MakeUnitUncommandable(gv_hERO_Raynor, false);
    libStEx_gf_TurnCinematicCameraOnOff(gv_pLAYER_01_USER, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1CZombiesInspireQ_Init () {
    gt__1CZombiesInspireQ = TriggerCreate("gt__1CZombiesInspireQ_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1C - Inspire Q
//--------------------------------------------------------------------------------------------------
bool gt__1CInspireQ_Func (bool testConds, bool runActions) {
    // Variable Declarations
    const fixed lv_requiredDistance = 1.0;

    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    UnitGroupLoopBegin(gv__1C_InspireAllies);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        libNtve_gf_ShareVisionofUnit(UnitGroupLoopCurrent(), true, gv_pLAYER_01_USER);
    }
    UnitGroupLoopEnd();
    if ((DistanceBetweenPoints(UnitGetPosition(gv_hERO_Raynor), PointFromId(283)) > lv_requiredDistance)) {
        libNtve_gf_MakeUnitUncommandable(gv_hERO_Raynor, true);
        UnitAbilityEnable(gv_hERO_Raynor, "attack", false);
        UnitAbilityEnable(gv_hERO_Raynor, "RaynorPenetratingRound", false);
        UnitIssueOrder(gv_hERO_Raynor, OrderTargetingPoint(AbilityCommand("move", 0), PointFromId(283)), c_orderQueueReplace);
        UnitIssueOrder(gv_hERO_Raynor, Order(AbilityCommand("move", 2)), c_orderQueueAddToEnd);
        while (!((DistanceBetweenPoints(UnitGetPosition(gv_hERO_Raynor), PointFromId(283)) <= lv_requiredDistance))) {
            Wait(0.0625, c_timeGame);
        }
        libNtve_gf_MakeUnitUncommandable(gv_hERO_Raynor, false);
    }
    else {
    }
    UnitIssueOrder(gv_hERO_Raynor, Order(AbilityCommand("move", 2)), c_orderQueueReplace);
    UnitAbilityEnable(gv_hERO_Raynor, "attack", false);
    UnitAbilityEnable(gv_hERO_Raynor, "move", false);
    UnitAbilityEnable(gv_hERO_Raynor, "RaynorPenetratingRound", false);
    TriggerQueueEnter();
    if ((gv__1C_InspireUsed == false)) {
        UnitAbilityShow(gv_hERO_Raynor, "RaynorInspire", true);
        libStEx_gf_HighlightCommandButton(true, 2);
        TriggerEnable(gt__1CInspireUsedQ, true);
        if ((gv__1C_InspireUsed == false)) {
            TriggerExecute(gt__1CInspireUseful, true, true);
        }
        else {
        }
        if ((gv__1C_InspireUsed == false)) {
            libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
            libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00287", c_transmissionDurationAdd, 0.0, true, 1, 0);
            libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
        }
        else {
        }
    }
    else {
    }
    if ((gv__1C_InspireUsed == false)) {
        TextExpressionSetToken("Param/Expression/F36C5787", "A", StringExternal("Param/Value/732D5EF5"));
        libStEx_gf_DisplayHintMessage(TextExpressionAssemble("Param/Expression/F36C5787"), true, 1.5);
    }
    else {
    }
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1CInspireQ_Init () {
    gt__1CInspireQ = TriggerCreate("gt__1CInspireQ_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1C - Inspire Useful
//--------------------------------------------------------------------------------------------------
bool gt__1CInspireUseful_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
    libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00286", c_transmissionDurationAdd, 0.0, true, 1, 0);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1CInspireUseful_Init () {
    gt__1CInspireUseful = TriggerCreate("gt__1CInspireUseful_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1C - Inspire Used Q
//--------------------------------------------------------------------------------------------------
bool gt__1CInspireUsedQ_Func (bool testConds, bool runActions) {
    unitgroup autoE46D3F0B_g;
    int autoE46D3F0B_u;
    unitgroup auto3D3E9A52_g;
    int auto3D3E9A52_u;

    // Variable Declarations
    unit lv_itUnit;
    point lv_position;
    point lv_positionCenter;
    point lv_positionTarget;
    fixed lv_distance;
    fixed lv_angle;

    // Variable Initialization

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

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerEnable(gt__1CInspireUsedMore, true);
    gv__1C_InspireUsed = true;
    libStEx_gf_ClearHintMessage();
    TriggerExecute(gt_AddReferenceCardInspire, true, false);
    libStEx_gf_HighlightCommandButton(false, 2);
    RegionPlayableMapSet(RegionFromId(2));
    UnitAbilityEnable(gv_hERO_Raynor, "move", true);
    UnitAbilityEnable(gv_hERO_Raynor, "attack", true);
    UnitAbilityEnable(gv_hERO_Raynor, "RaynorPenetratingRound", true);
    UnitAbilityShow(gv_hERO_Raynor, "RaynorPenetratingRound", true);
    Wait(0.7, c_timeGame);
    autoE46D3F0B_g = gv__1C_InspireAllies;
    autoE46D3F0B_u = 1;
    for ( ; autoE46D3F0B_u <= UnitGroupCount(autoE46D3F0B_g, c_unitCountAll) ; autoE46D3F0B_u += BoolToInt(lv_itUnit == UnitGroupUnit(autoE46D3F0B_g, autoE46D3F0B_u)) ) {
        lv_itUnit = UnitGroupUnit(autoE46D3F0B_g, autoE46D3F0B_u);
        lv_position = UnitGetPosition(lv_itUnit);
        lv_positionCenter = PointFromId(283);
        lv_distance = DistanceBetweenPoints(lv_positionCenter, lv_position);
        lv_angle = AngleBetweenPoints(lv_positionCenter, lv_position);
        lv_positionTarget = PointFromId(55);
        libCore_gf_StorePointForUnit(lv_itUnit, 1, PointWithOffsetPolar(lv_positionTarget, lv_distance, (lv_angle + (PointGetFacing(lv_positionTarget) - PointGetFacing(lv_positionCenter)))));
        lv_positionTarget = PointFromId(428);
        libCore_gf_StorePointForUnit(lv_itUnit, 2, PointWithOffsetPolar(lv_positionTarget, lv_distance, (lv_angle + (PointGetFacing(lv_positionTarget) - PointGetFacing(lv_positionCenter)))));
        lv_positionTarget = PointFromId(528);
        libCore_gf_StorePointForUnit(lv_itUnit, 3, PointWithOffsetPolar(lv_positionTarget, lv_distance, (lv_angle + (PointGetFacing(lv_positionTarget) - PointGetFacing(lv_positionCenter)))));
    }
    TriggerQueueEnter();
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
    libCore_gf_SendTransmissionCampaign(UnitFromId(285), "TutorialVO|Line00288", c_transmissionDurationAdd, 0.0, false, 1, 0);
    Wait(2.0, c_timeGame);
    auto3D3E9A52_g = gv__1C_InspireAllies;
    auto3D3E9A52_u = 1;
    for ( ; auto3D3E9A52_u <= UnitGroupCount(auto3D3E9A52_g, c_unitCountAll) ; auto3D3E9A52_u += BoolToInt(lv_itUnit == UnitGroupUnit(auto3D3E9A52_g, auto3D3E9A52_u)) ) {
        lv_itUnit = UnitGroupUnit(auto3D3E9A52_g, auto3D3E9A52_u);
        UnitIssueOrder(lv_itUnit, OrderTargetingPoint(AbilityCommand("attack", 0), libCore_gf_PointStoredForUnit(lv_itUnit, 1)), c_orderQueueReplace);
    }
    TransmissionWait(TransmissionLastSent(), 0.0);
    libCore_gf_SendTransmissionCampaign(gv_hERO_Raynor, "TutorialVO|Line00316", c_transmissionDurationAdd, 0.0, true, 1, 0);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1CInspireUsedQ_Init () {
    gt__1CInspireUsedQ = TriggerCreate("gt__1CInspireUsedQ_Func");
    TriggerEnable(gt__1CInspireUsedQ, false);
    TriggerAddEventUnitAbility(gt__1CInspireUsedQ, UnitRefFromVariable("gv_hERO_Raynor"), AbilityCommand("RaynorInspire", 0), c_unitAbilStageComplete, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1C - Inspire Use More Q
//--------------------------------------------------------------------------------------------------
bool gt__1CInspireUseMoreQ_Func (bool testConds, bool runActions) {
    int autoC9275B65_n;
    int autoC9275B65_i;
    unitgroup auto7E85A716_g;
    int auto7E85A716_u;

    // Variable Declarations
    unit lv_itUnit;
    bool lv_inspired;

    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((gv__1C_InspireUsedMore == false))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    autoC9275B65_n = 20;
    for (autoC9275B65_i = 1; autoC9275B65_i <= autoC9275B65_n; autoC9275B65_i += 1) {
        lv_inspired = false;
        auto7E85A716_g = gv__1C_InspireAllies;
        auto7E85A716_u = 1;
        for ( ; auto7E85A716_u <= UnitGroupCount(auto7E85A716_g, c_unitCountAll) ; auto7E85A716_u += BoolToInt(lv_itUnit == UnitGroupUnit(auto7E85A716_g, auto7E85A716_u)) ) {
            lv_itUnit = UnitGroupUnit(auto7E85A716_g, auto7E85A716_u);
            if ((UnitHasBehavior2(lv_itUnit, "RaynorInspireAlly") == true)) {
                lv_inspired = true;
                break;
            }
            else {
            }
        }
        if ((lv_inspired == false)) {
            break;
        }
        else {
        }
        Wait(0.5, c_timeGame);
    }
    if (((lv_inspired == true) || (UnitGroupCount(gv__1C_Zombies5, c_unitCountAlive) < 7))) {
        return true;
    }
    else {
    }
    TriggerQueueEnter();
    TriggerEnable(gt__1CInspireUsedMore, true);
    libStEx_gf_HighlightCommandButton(true, 2);
    TriggerEnable(gt__1CInspireUseful, false);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
    libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00451", c_transmissionDurationAdd, 0.0, true, 1, 0);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
    if ((gv__1C_InspireUsedMore == false)) {
        TextExpressionSetToken("Param/Expression/336B15F7", "A", StringExternal("Param/Value/27E69A35"));
        libStEx_gf_DisplayHintMessage(TextExpressionAssemble("Param/Expression/336B15F7"), true, 1.5);
    }
    else {
    }
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1CInspireUseMoreQ_Init () {
    gt__1CInspireUseMoreQ = TriggerCreate("gt__1CInspireUseMoreQ_Func");
    TriggerEnable(gt__1CInspireUseMoreQ, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1C - Inspire Used More
//--------------------------------------------------------------------------------------------------
bool gt__1CInspireUsedMore_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((gv__1C_InspireUsedMore == false))) {
            return false;
        }
    }

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

    gv__1C_InspireUsedMore = true;
    libStEx_gf_HighlightCommandButton(false, 2);
    libStEx_gf_ClearHintMessage();
    TriggerQueueEnter();
    TriggerExecute(gt__1CInspireUseful, true, true);
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1CInspireUsedMore_Init () {
    gt__1CInspireUsedMore = TriggerCreate("gt__1CInspireUsedMore_Func");
    TriggerEnable(gt__1CInspireUsedMore, false);
    TriggerAddEventUnitAbility(gt__1CInspireUsedMore, UnitRefFromVariable("gv_hERO_Raynor"), AbilityCommand("RaynorInspire", 0), c_unitAbilStageComplete, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1C - Inspire Use More More Q
//--------------------------------------------------------------------------------------------------
bool gt__1CInspireUseMoreMoreQ_Func (bool testConds, bool runActions) {
    int auto36CACB13_n;
    int auto36CACB13_i;
    unitgroup autoCC30D0A3_g;
    int autoCC30D0A3_u;

    // Variable Declarations
    unit lv_itUnit;
    bool lv_inspired;

    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((gv__1C_InspireUsedMoreMore == false))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    auto36CACB13_n = 20;
    for (auto36CACB13_i = 1; auto36CACB13_i <= auto36CACB13_n; auto36CACB13_i += 1) {
        lv_inspired = false;
        autoCC30D0A3_g = gv__1C_InspireAllies;
        autoCC30D0A3_u = 1;
        for ( ; autoCC30D0A3_u <= UnitGroupCount(autoCC30D0A3_g, c_unitCountAll) ; autoCC30D0A3_u += BoolToInt(lv_itUnit == UnitGroupUnit(autoCC30D0A3_g, autoCC30D0A3_u)) ) {
            lv_itUnit = UnitGroupUnit(autoCC30D0A3_g, autoCC30D0A3_u);
            if ((UnitHasBehavior2(lv_itUnit, "RaynorInspireAlly") == true)) {
                lv_inspired = true;
                break;
            }
            else {
            }
        }
        if ((lv_inspired == false)) {
            break;
        }
        else {
        }
        Wait(0.5, c_timeGame);
    }
    if (((lv_inspired == true) || (UnitGroupCount(gv__1C_Zombies6, c_unitCountAlive) < 20))) {
        return true;
    }
    else {
    }
    TriggerQueueEnter();
    TriggerEnable(gt__1CInspireUsedMoreMore, true);
    libStEx_gf_HighlightCommandButton(true, 2);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
    libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00317", c_transmissionDurationAdd, 0.0, true, 1, 0);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
    if ((gv__1C_InspireUsedMoreMore == false)) {
        TextExpressionSetToken("Param/Expression/1A2DE6E3", "A", StringExternal("Param/Value/760E9346"));
        libStEx_gf_DisplayHintMessage(TextExpressionAssemble("Param/Expression/1A2DE6E3"), true, 1.5);
    }
    else {
    }
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1CInspireUseMoreMoreQ_Init () {
    gt__1CInspireUseMoreMoreQ = TriggerCreate("gt__1CInspireUseMoreMoreQ_Func");
    TriggerEnable(gt__1CInspireUseMoreMoreQ, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1C - Inspire Used More More
//--------------------------------------------------------------------------------------------------
bool gt__1CInspireUsedMoreMore_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((gv__1C_InspireUsedMoreMore == false))) {
            return false;
        }
    }

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

    gv__1C_InspireUsedMoreMore = true;
    libStEx_gf_HighlightCommandButton(false, 2);
    libStEx_gf_ClearHintMessage();
    TriggerQueueEnter();
    TriggerExecute(gt__1CInspireUseful, true, true);
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1CInspireUsedMoreMore_Init () {
    gt__1CInspireUsedMoreMore = TriggerCreate("gt__1CInspireUsedMoreMore_Func");
    TriggerEnable(gt__1CInspireUsedMoreMore, false);
    TriggerAddEventUnitAbility(gt__1CInspireUsedMoreMore, UnitRefFromVariable("gv_hERO_Raynor"), AbilityCommand("RaynorInspire", 0), c_unitAbilStageComplete, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1C - Zombie Dies
//--------------------------------------------------------------------------------------------------
bool gt__1CZombieDies_Func (bool testConds, bool runActions) {
    // Variable Declarations
    fixed lv_angle;
    unit lv_itUnit;

    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((UnitGroupHasUnit(gv__1C_Zombies, EventUnit()) == true))) {
            return false;
        }

        if (!((gv__1C_ZombieCountKilled < gv__1C_ZombieCountTotal))) {
            return false;
        }
    }

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

    gv__1C_ZombieCountKilled += 1;
    TriggerExecute(gt_ObjectiveKillZombiesUpdate, true, false);
    if ((gv__1C_ZombieCountKilled >= gv__1C_ZombieCountTotal)) {
        TriggerEnable(TriggerGetCurrent(), false);
        libStEx_gf_ClearHintMessage();
        libStEx_gf_HighlightCommandButton(false, 1);
        libStEx_gf_HighlightCommandButton(false, 2);
        TriggerExecute(gt_ObjectiveKillZombiesComplete, true, false);
        Wait(3.0, c_timeReal);
        TriggerExecute(gt__1DCameraLockQ, true, false);
        return true;
    }
    else {
    }
    TriggerExecute(gt__1CZombiesInspireQ, true, false);
    if ((UnitGroupHasUnit(gv__1C_Zombies4, EventUnit()) == true) && (libNtve_gf_UnitGroupIsDead(gv__1C_Zombies4) == true)) {
        TriggerExecute(gt__1CZombieAllyAttack4, true, false);
    }
    else {
    }
    if ((UnitGroupHasUnit(gv__1C_Zombies5, EventUnit()) == true) && (libNtve_gf_UnitGroupIsDead(gv__1C_Zombies5) == true)) {
        TriggerExecute(gt__1CZombieAllyAttack5, true, false);
    }
    else {
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1CZombieDies_Init () {
    gt__1CZombieDies = TriggerCreate("gt__1CZombieDies_Func");
    TriggerEnable(gt__1CZombieDies, false);
    TriggerAddEventUnitDied(gt__1CZombieDies, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1C - Zombie Ally Attack 4
//--------------------------------------------------------------------------------------------------
bool gt__1CZombieAllyAttack4_Func (bool testConds, bool runActions) {
    unitgroup auto255876A8_g;
    int auto255876A8_u;

    // Variable Declarations
    fixed lv_angle;
    unit lv_itUnit;

    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    while (true) {
        lv_angle = libCore_gf_StandalizedAngle(AngleBetweenPoints(PointFromId(55), UnitGetPosition(gv_hERO_Raynor)));
        if ((lv_angle <= 80.0) && (lv_angle >= -80.0)) {
            auto255876A8_g = gv__1C_InspireAllies;
            auto255876A8_u = 1;
            for ( ; auto255876A8_u <= UnitGroupCount(auto255876A8_g, c_unitCountAll) ; auto255876A8_u += BoolToInt(lv_itUnit == UnitGroupUnit(auto255876A8_g, auto255876A8_u)) ) {
                lv_itUnit = UnitGroupUnit(auto255876A8_g, auto255876A8_u);
                UnitIssueOrder(lv_itUnit, OrderTargetingPoint(AbilityCommand("attack", 0), libCore_gf_PointStoredForUnit(lv_itUnit, 2)), c_orderQueueReplace);
            }
            Wait(1.0, c_timeGame);
            TriggerExecute(gt__1CInspireUseMoreQ, true, false);
            gv__1C_InspireUsedMore = false;
            break;
        }
        else {
        }
        Wait(0.25, c_timeGame);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1CZombieAllyAttack4_Init () {
    gt__1CZombieAllyAttack4 = TriggerCreate("gt__1CZombieAllyAttack4_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1C - Zombie Ally Attack 5
//--------------------------------------------------------------------------------------------------
bool gt__1CZombieAllyAttack5_Func (bool testConds, bool runActions) {
    unitgroup autoE13C5EB0_g;
    int autoE13C5EB0_u;

    // Variable Declarations
    fixed lv_angle;
    unit lv_itUnit;

    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    while (true) {
        lv_angle = libCore_gf_StandalizedAngle(AngleBetweenPoints(PointFromId(428), UnitGetPosition(gv_hERO_Raynor)));
        if ((lv_angle <= 80.0) && (lv_angle >= -80.0)) {
            autoE13C5EB0_g = gv__1C_InspireAllies;
            autoE13C5EB0_u = 1;
            for ( ; autoE13C5EB0_u <= UnitGroupCount(autoE13C5EB0_g, c_unitCountAll) ; autoE13C5EB0_u += BoolToInt(lv_itUnit == UnitGroupUnit(autoE13C5EB0_g, autoE13C5EB0_u)) ) {
                lv_itUnit = UnitGroupUnit(autoE13C5EB0_g, autoE13C5EB0_u);
                UnitIssueOrder(lv_itUnit, OrderTargetingPoint(AbilityCommand("attack", 0), libCore_gf_PointStoredForUnit(lv_itUnit, 3)), c_orderQueueReplace);
            }
            Wait(1.0, c_timeGame);
            TriggerExecute(gt__1CInspireUseMoreMoreQ, true, false);
            break;
        }
        else {
        }
        Wait(0.25, c_timeGame);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1CZombieAllyAttack5_Init () {
    gt__1CZombieAllyAttack5 = TriggerCreate("gt__1CZombieAllyAttack5_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1C - Zombie Attacked
//--------------------------------------------------------------------------------------------------
bool gt__1CZombieAttacked_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unitgroup lv_attackedGroup;

    // Variable Initialization
    lv_attackedGroup = UnitGroupEmpty();

    // Conditions
    if (testConds) {
        if (!((UnitGetType(EventUnit()) == "NecromancerMinionSkeleton"))) {
            return false;
        }
    }

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

    if ((UnitGroupHasUnit(gv__1C_Zombies2, EventUnit()) == true)) {
        lv_attackedGroup = gv__1C_Zombies2;
    }
    else if ((UnitGroupHasUnit(gv__1C_Zombies3, EventUnit()) == true)) {
        lv_attackedGroup = gv__1C_Zombies3;
    }
    else if ((UnitGroupHasUnit(gv__1C_Zombies4, EventUnit()) == true)) {
        lv_attackedGroup = gv__1C_Zombies4;
    }
    else if ((UnitGroupHasUnit(gv__1C_Zombies5, EventUnit()) == true)) {
        lv_attackedGroup = gv__1C_Zombies5;
    }
    else if ((UnitGroupHasUnit(gv__1C_Zombies6, EventUnit()) == true)) {
        lv_attackedGroup = gv__1C_Zombies6;
    }
    else if (true) {
        return true;
    }
    UnitGroupLoopBegin(lv_attackedGroup);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        UnitIssueOrder(UnitGroupLoopCurrent(), OrderTargetingPoint(AbilityCommand("attack", 0), UnitGetPosition(gv_hERO_Raynor)), c_orderQueueReplace);
        UnitIssueOrder(UnitGroupLoopCurrent(), OrderTargetingUnit(AbilityCommand("attack", 0), gv_hERO_Raynor), c_orderQueueAddToEnd);
    }
    UnitGroupLoopEnd();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1CZombieAttacked_Init () {
    gt__1CZombieAttacked = TriggerCreate("gt__1CZombieAttacked_Func");
    TriggerEnable(gt__1CZombieAttacked, false);
    TriggerAddEventUnitAttacked2(gt__1CZombieAttacked, null, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1C - Zombies2 Approached
//--------------------------------------------------------------------------------------------------
bool gt__1CZombies2Approached_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerEnable(TriggerGetCurrent(), false);
    UnitGroupLoopBegin(gv__1C_Zombies2);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        UnitIssueOrder(UnitGroupLoopCurrent(), OrderTargetingPoint(AbilityCommand("attack", 0), UnitGetPosition(gv_hERO_Raynor)), c_orderQueueReplace);
        UnitIssueOrder(UnitGroupLoopCurrent(), OrderTargetingUnit(AbilityCommand("attack", 0), gv_hERO_Raynor), c_orderQueueAddToEnd);
    }
    UnitGroupLoopEnd();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1CZombies2Approached_Init () {
    gt__1CZombies2Approached = TriggerCreate("gt__1CZombies2Approached_Func");
    TriggerAddEventUnitRegion(gt__1CZombies2Approached, UnitRefFromVariable("gv_hERO_Raynor"), RegionFromId(20), true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1C - Zombies3 Approached
//--------------------------------------------------------------------------------------------------
bool gt__1CZombies3Approached_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerEnable(TriggerGetCurrent(), false);
    UnitGroupLoopBegin(gv__1C_Zombies3);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        UnitIssueOrder(UnitGroupLoopCurrent(), OrderTargetingPoint(AbilityCommand("attack", 0), UnitGetPosition(gv_hERO_Raynor)), c_orderQueueReplace);
        UnitIssueOrder(UnitGroupLoopCurrent(), OrderTargetingUnit(AbilityCommand("attack", 0), gv_hERO_Raynor), c_orderQueueAddToEnd);
    }
    UnitGroupLoopEnd();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1CZombies3Approached_Init () {
    gt__1CZombies3Approached = TriggerCreate("gt__1CZombies3Approached_Func");
    TriggerAddEventUnitRegion(gt__1CZombies3Approached, UnitRefFromVariable("gv_hERO_Raynor"), RegionFromId(28), true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1C - Zombies4 Approached
//--------------------------------------------------------------------------------------------------
bool gt__1CZombies4Approached_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerEnable(TriggerGetCurrent(), false);
    UnitGroupLoopBegin(gv__1C_Zombies4);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        UnitIssueOrder(UnitGroupLoopCurrent(), OrderTargetingPoint(AbilityCommand("attack", 0), UnitGetPosition(gv_hERO_Raynor)), c_orderQueueReplace);
        UnitIssueOrder(UnitGroupLoopCurrent(), OrderTargetingUnit(AbilityCommand("attack", 0), gv_hERO_Raynor), c_orderQueueAddToEnd);
    }
    UnitGroupLoopEnd();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1CZombies4Approached_Init () {
    gt__1CZombies4Approached = TriggerCreate("gt__1CZombies4Approached_Func");
    TriggerAddEventUnitRegion(gt__1CZombies4Approached, UnitRefFromVariable("gv_hERO_Raynor"), RegionFromId(21), true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1C - Zombies5 Approached
//--------------------------------------------------------------------------------------------------
bool gt__1CZombies5Approached_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerEnable(TriggerGetCurrent(), false);
    UnitGroupLoopBegin(gv__1C_Zombies5);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        UnitIssueOrder(UnitGroupLoopCurrent(), OrderTargetingPoint(AbilityCommand("attack", 0), UnitGetPosition(gv_hERO_Raynor)), c_orderQueueReplace);
        UnitIssueOrder(UnitGroupLoopCurrent(), OrderTargetingUnit(AbilityCommand("attack", 0), gv_hERO_Raynor), c_orderQueueAddToEnd);
    }
    UnitGroupLoopEnd();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1CZombies5Approached_Init () {
    gt__1CZombies5Approached = TriggerCreate("gt__1CZombies5Approached_Func");
    TriggerAddEventUnitRegion(gt__1CZombies5Approached, UnitRefFromVariable("gv_hERO_Raynor"), RegionFromId(27), true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1C - Zombies6 Approached
//--------------------------------------------------------------------------------------------------
bool gt__1CZombies6Approached_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerEnable(TriggerGetCurrent(), false);
    UnitGroupLoopBegin(gv__1C_Zombies6);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        UnitIssueOrder(UnitGroupLoopCurrent(), OrderTargetingPoint(AbilityCommand("attack", 0), UnitGetPosition(gv_hERO_Raynor)), c_orderQueueReplace);
        UnitIssueOrder(UnitGroupLoopCurrent(), OrderTargetingUnit(AbilityCommand("attack", 0), gv_hERO_Raynor), c_orderQueueAddToEnd);
    }
    UnitGroupLoopEnd();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1CZombies6Approached_Init () {
    gt__1CZombies6Approached = TriggerCreate("gt__1CZombies6Approached_Func");
    TriggerAddEventUnitRegion(gt__1CZombies6Approached, UnitRefFromVariable("gv_hERO_Raynor"), RegionFromId(1), true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1C - Zombies3 Drop Globe
//--------------------------------------------------------------------------------------------------
bool gt__1CZombies3DropGlobe_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((UnitGroupHasUnit(gv__1C_Zombies3, EventUnit()) == true))) {
            return false;
        }

        if (!((libNtve_gf_UnitGroupIsDead(gv__1C_Zombies3) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    UnitCreate(1, "RegenGlobe", c_unitCreateIgnorePlacement, gv_pLAYER_11_ORDER, UnitGetPosition(EventUnit()), 270.0);
    UnitBehaviorRemovePlayer(UnitLastCreated(), "RegenGlobeTimedLife", gv_pLAYER_01_USER, 1);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1CZombies3DropGlobe_Init () {
    gt__1CZombies3DropGlobe = TriggerCreate("gt__1CZombies3DropGlobe_Func");
    TriggerAddEventUnitDied(gt__1CZombies3DropGlobe, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1D - Camera Lock Q
//--------------------------------------------------------------------------------------------------
bool gt__1DCameraLockQ_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    libNtve_gf_MakeUnitUncommandable(gv_hERO_Raynor, true);
    TriggerQueueEnter();
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
    libCore_gf_SendTransmissionCampaign(gv_hERO_Diablo, "TutorialVO|Line00290", c_transmissionDurationAdd, 0.0, true, 1, 0);
    libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00291", c_transmissionDurationAdd, 0.0, true, 1, 0);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
    TriggerEnable(gt__1DCameraUnlocked, true);
    if ((gv__1D_CameraLockButtonClicked == false)) {
        TextExpressionSetToken("Param/Expression/85457D44", "A", libStEx_gf_CameraLockHotkeyText());
        libStEx_gf_DisplayHintMessage(TextExpressionAssemble("Param/Expression/85457D44"), true, 1.5);
        Wait(2.0, c_timeGame);
    }
    else {
    }
    while (!((gv__1D_CameraLockButtonClicked == true))) {
        Wait(0.25, c_timeGame);
    }
    UnitSetPosition(gv_hERO_Diablo, libCore_gf_PointStoredForUnit(gv_hERO_Diablo, 1), false);
    libNtve_gf_ShowHideUnit(gv_hERO_Diablo, true);
    gf_SetPlayableWithLooseCameraBounds(RegionFromId(41));
    VisRevealerCreate(1, RegionFromId(36));
    gv__1D_DiabloRevealer = VisRevealerLastCreated();
    libNtve_gf_MakeUnitInvulnerable(gv_hERO_Diablo, false);
    UnitSetPropertyFixed(gv_hERO_Diablo, c_unitPropLifePercent, 55.0);
    UnitSetState(gv_hERO_Diablo, c_unitStateTargetable, true);
    UnitGroupLoopBegin(gv__1D_DiabloFightMinion);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        libNtve_gf_PauseUnit(UnitGroupLoopCurrent(), false);
        UnitIssueOrder(UnitGroupLoopCurrent(), OrderTargetingUnit(AbilityCommand("attack", 0), gv_hERO_Diablo), c_orderQueueReplace);
    }
    UnitGroupLoopEnd();
    TriggerExecute(gt__1DCameraLocationLogic, true, false);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
    libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00292", c_transmissionDurationAdd, 0.0, false, 1, 0);
    gv__1D_MoveCameraTransmission = TransmissionLastSent();
    TransmissionWait(TransmissionLastSent(), 0.0);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
    libStEx_gf_LockUnlockTutorialCamera(false);
    libNtve_gf_SetDialogItemUnit(libUIUI_gv_uIHeroTrackerArrow.lv_arrow, gv_hERO_Diablo, libCore_gv_playerGroupFromPlayer[1]);
    libNtve_gf_SetDialogItemImage(libUIUI_gv_uIHeroTrackerArrow.lv_portraitImage, (CatalogFieldValueGet(c_gameCatalogActor, "HeroDiablo", "MinimapIcon", c_playerAny)), libCore_gv_playerGroupFromPlayer[1]);
    DialogControlSetVisible(libUIUI_gv_uIHeroTrackerArrow.lv_mainPanel, PlayerGroupAll(), true);
    Wait(1.0, c_timeGame);
    TriggerExecute(gt_ObjectiveFindDiabloCreate, true, true);
    libNtve_gf_CreatePingFacingAngle(PlayerGroupAll(), "PingAlert", UnitGetPosition(gv_hERO_Diablo), ColorWithAlpha(100.00, 100.00, 0.00, 0.00), 0.0, 270.0);
    gv__1D_DiabloPing = PingLastCreated();
    TriggerExecute(gt__1DCameraArrowLogic, true, false);
    if ((gv__1D_DiabloFound == false)) {
        Wait(1.0, c_timeGame);
        if ((gv__1D_DiabloFound == false)) {
            libStEx_gf_DisplayHintMessage(StringExternal("Param/Value/B3B9FD07"), true, 1.5);
            Wait(1.0, c_timeGame);
        }
        else {
        }
    }
    else {
    }
    while (!((gv__1D_DiabloFound == true))) {
        Wait(1.0, c_timeGame);
    }
    gv__1D_DiabloFound = true;
    libStEx_gf_ClearHintMessage();
    CameraPan(1, CameraInfoGetTarget(CameraInfoFromId(696)), 2.0, -1, 10.0, false);
    CameraLockInput(1, true);
    PingDestroy(gv__1D_DiabloPing);
    gv__1D_DiabloPing = c_invalidPingId;
    UnitGroupLoopBegin(gv__1D_DiabloFightMinion);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        libNtve_gf_ChangeUnitDamage(UnitGroupLoopCurrent(), 0, 0);
    }
    UnitGroupLoopEnd();
    Wait(2.0, c_timeGame);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
    libCore_gf_SendTransmissionCampaign(gv_hERO_Diablo, "TutorialVO|Line00293", c_transmissionDurationAdd, 0.0, false, 1, 0);
    Wait(1.0, c_timeGame);
    UnitIssueOrder(gv_hERO_Diablo, Order(AbilityCommand("DiabloFireStomp", 0)), c_orderQueueReplace);
    Wait(0.6, c_timeGame);
    UnitGroupLoopBegin(gv__1D_DiabloFightMinion);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        UnitKill(UnitGroupLoopCurrent());
    }
    UnitGroupLoopEnd();
    UnitGroupLoopBegin(gv__1C_InspireAllies);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        UnitRemove(UnitGroupLoopCurrent());
    }
    UnitGroupLoopEnd();
    UnitIssueOrder(gv_hERO_Diablo, OrderTargetingPoint(AbilityCommand("move", 4), PointFromId(697)), c_orderQueueAddToEnd);
    UnitSetPosition(gv_hERO_Raynor, PointFromId(528), false);
    UnitSetFacing(gv_hERO_Raynor, PointGetFacing(PointFromId(528)), 0.0);
    TransmissionWait(TransmissionLastSent(), 0.0);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
    TriggerExecute(gt_ObjectiveFindDiabloComplete, true, false);
    Wait(1.0, c_timeGame);
    TriggerExecute(gt__1DDiabloFightQ, true, false);
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1DCameraLockQ_Init () {
    gt__1DCameraLockQ = TriggerCreate("gt__1DCameraLockQ_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1D - Camera Unlocked
//--------------------------------------------------------------------------------------------------
bool gt__1DCameraUnlocked_Func (bool testConds, bool runActions) {
    // Variable Declarations
    text lv_label;

    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((libNtve_gf_PlayerInCinematicMode(gv_pLAYER_01_USER) == false))) {
            return false;
        }
    }

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

    gv__1D_CameraLockButtonClicked = true;
    if ((gv__1D_CameraInitroLockButtonClicked == false)) {
        TriggerEnable(TriggerGetCurrent(), false);
        gv__1D_CameraInitroLockButtonClicked = true;
        libStEx_gf_ClearHintMessage();
        TriggerEnable(gt__1DCameraMoved, true);
    }
    else {
    }
    if ((libStEx_gf_TutorialCameraLocked() == true)) {
        libStEx_gf_LockUnlockTutorialCamera(false);
        libUIUI_gf_DisplayCameraLockNotificationText(false, gv_pLAYER_01_USER);
    }
    else {
        libStEx_gf_LockUnlockTutorialCamera(true);
        libUIUI_gf_DisplayCameraLockNotificationText(true, gv_pLAYER_01_USER);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1DCameraUnlocked_Init () {
    gt__1DCameraUnlocked = TriggerCreate("gt__1DCameraUnlocked_Func");
    TriggerEnable(gt__1DCameraUnlocked, false);
    TriggerAddEventKeyPressed(gt__1DCameraUnlocked, c_playerAny, c_keyC, true, c_keyModifierStateExclude, c_keyModifierStateExclude, c_keyModifierStateExclude);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1D - Camera Moved
//--------------------------------------------------------------------------------------------------
bool gt__1DCameraMoved_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerEnable(TriggerGetCurrent(), false);
    libStEx_gf_ClearHintMessage();
    gv__1D_CameraMoved = true;
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1DCameraMoved_Init () {
    gt__1DCameraMoved = TriggerCreate("gt__1DCameraMoved_Func");
    TriggerEnable(gt__1DCameraMoved, false);
    TriggerAddEventCameraMove(gt__1DCameraMoved, 1, c_cameraMoveReasonAny);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1D - Camera Spacebar Pressed
//--------------------------------------------------------------------------------------------------
bool gt__1DCameraSpacebarPressed_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerEnable(TriggerGetCurrent(), false);
    libStEx_gf_ClearHintMessage();
    gv__1D_SpacebarPressed = true;
    CameraLockInput(1, false);
    CameraPan(1, UnitGetPosition(gv_hERO_Raynor), 0.0, -1, 10.0, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1DCameraSpacebarPressed_Init () {
    gt__1DCameraSpacebarPressed = TriggerCreate("gt__1DCameraSpacebarPressed_Func");
    TriggerEnable(gt__1DCameraSpacebarPressed, false);
    TriggerAddEventKeyPressed(gt__1DCameraSpacebarPressed, c_playerAny, c_keySpace, true, c_keyModifierStateIgnore, c_keyModifierStateIgnore, c_keyModifierStateIgnore);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1D - Camera Arrow Logic
//--------------------------------------------------------------------------------------------------
bool gt__1DCameraArrowLogic_Func (bool testConds, bool runActions) {
    int init_i;

    // Variable Declarations
    int[5] lv_arrowImg;
    bool lv_arrowDisplayed;

    // Variable Initialization
    for (init_i = 0; init_i <= 4; init_i += 1) {
        lv_arrowImg[init_i] = c_invalidDialogControlId;
    }

    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    while (true) {
        if ((gv__1D_DiabloFound == true) && (((gv__1D_CameraArrowPointing[1] == false) && (gv__1D_CameraArrowPointing[2] == false) && (gv__1D_CameraArrowPointing[3] == false) && (gv__1D_CameraArrowPointing[4] == false)))) {
            gv__1D_DiabloFound = true;
            if ((gv__1D_MoveCameraTransmission != c_invalidTransmissionId)) {
                TransmissionClear(gv__1D_MoveCameraTransmission);
            }
            else {
            }
            if ((lv_arrowDisplayed == true)) {
                IntLoopBegin(1, 4);
                for ( ; !IntLoopDone() ; IntLoopStep() ) {
                    libNtve_gf_HideScreenImage(false, IntLoopCurrent());
                }
                IntLoopEnd();
            }
            else {
            }
            return true;
        }
        else {
        }
        if ((lv_arrowDisplayed == false)) {
            lv_arrowDisplayed = true;
            libNtve_gf_DisplayScreenImage(1, "Assets\\Textures\\ui_tutorial_arrow04.dds", c_triggerBlendModeAdd, 128, 128, c_anchorRight, 0, 0);
            lv_arrowImg[1] = libNtve_gf_ScreenImageDialogItem(1);
            libNtve_gf_DisplayScreenImage(2, "Assets\\Textures\\ui_tutorial_arrow04.dds", c_triggerBlendModeAdd, 128, 128, c_anchorTop, 0, 0);
            lv_arrowImg[2] = libNtve_gf_ScreenImageDialogItem(2);
            libNtve_gf_SetDialogItemRotation(lv_arrowImg[2], 270, PlayerGroupAll());
            libNtve_gf_DisplayScreenImage(3, "Assets\\Textures\\ui_tutorial_arrow04.dds", c_triggerBlendModeAdd, 128, 128, c_anchorLeft, 0, 0);
            lv_arrowImg[3] = libNtve_gf_ScreenImageDialogItem(3);
            libNtve_gf_SetDialogItemRotation(lv_arrowImg[3], 180, PlayerGroupAll());
            libNtve_gf_DisplayScreenImage(4, "Assets\\Textures\\ui_tutorial_arrow04.dds", c_triggerBlendModeAdd, 128, 128, c_anchorBottom, 0, 0);
            lv_arrowImg[4] = libNtve_gf_ScreenImageDialogItem(4);
            libNtve_gf_SetDialogItemRotation(lv_arrowImg[4], 90, PlayerGroupAll());
        }
        else {
        }
        IntLoopBegin(1, 4);
        for ( ; !IntLoopDone() ; IntLoopStep() ) {
            if ((gv__1D_CameraArrowPointing[IntLoopCurrent()] == true)) {
                DialogControlSetVisible(lv_arrowImg[IntLoopCurrent()], PlayerGroupAll(), true);
            }
            else {
                DialogControlSetVisible(lv_arrowImg[IntLoopCurrent()], PlayerGroupAll(), false);
            }
        }
        IntLoopEnd();
        IntLoopBegin(1, 4);
        for ( ; !IntLoopDone() ; IntLoopStep() ) {
            libNtve_gf_SetDialogItemImage(lv_arrowImg[IntLoopCurrent()], "Assets\\Textures\\ui_tutorial_arrow04.dds", PlayerGroupAll());
        }
        IntLoopEnd();
        Wait(0.15, c_timeGame);
        IntLoopBegin(1, 4);
        for ( ; !IntLoopDone() ; IntLoopStep() ) {
            libNtve_gf_SetDialogItemImage(lv_arrowImg[IntLoopCurrent()], "Assets\\Textures\\ui_tutorial_arrow03.dds", PlayerGroupAll());
        }
        IntLoopEnd();
        Wait(0.15, c_timeGame);
        IntLoopBegin(1, 4);
        for ( ; !IntLoopDone() ; IntLoopStep() ) {
            libNtve_gf_SetDialogItemImage(lv_arrowImg[IntLoopCurrent()], "Assets\\Textures\\ui_tutorial_arrow02.dds", PlayerGroupAll());
        }
        IntLoopEnd();
        Wait(0.15, c_timeGame);
        IntLoopBegin(1, 4);
        for ( ; !IntLoopDone() ; IntLoopStep() ) {
            libNtve_gf_SetDialogItemImage(lv_arrowImg[IntLoopCurrent()], "Assets\\Textures\\ui_tutorial_arrow01.dds", PlayerGroupAll());
        }
        IntLoopEnd();
        Wait(0.25, c_timeGame);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1DCameraArrowLogic_Init () {
    gt__1DCameraArrowLogic = TriggerCreate("gt__1DCameraArrowLogic_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1D - Camera Location Logic
//--------------------------------------------------------------------------------------------------
bool gt__1DCameraLocationLogic_Func (bool testConds, bool runActions) {
    // Variable Declarations
    point lv_cameraTarget;
    point lv_diabloLoc;

    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    lv_diabloLoc = UnitGetPosition(gv_hERO_Diablo);
    while (true) {
        lv_cameraTarget = CameraGetTarget(gv_pLAYER_01_USER);
        if ((PointGetX(lv_cameraTarget) < (PointGetX(lv_diabloLoc) - 7.0))) {
            gv__1D_CameraArrowPointing[1] = true;
        }
        else {
            gv__1D_CameraArrowPointing[1] = false;
        }
        if ((PointGetY(lv_cameraTarget) < (PointGetY(lv_diabloLoc) - 5.0))) {
            gv__1D_CameraArrowPointing[2] = true;
        }
        else {
            gv__1D_CameraArrowPointing[2] = false;
        }
        if ((PointGetX(lv_cameraTarget) > (PointGetX(lv_diabloLoc) + 7.0))) {
            gv__1D_CameraArrowPointing[3] = true;
        }
        else {
            gv__1D_CameraArrowPointing[3] = false;
        }
        if ((PointGetY(lv_cameraTarget) > (PointGetY(lv_diabloLoc) + 5.0))) {
            gv__1D_CameraArrowPointing[4] = true;
        }
        else {
            gv__1D_CameraArrowPointing[4] = false;
        }
        if ((gv__1D_CameraArrowPointing[1] == false) && (gv__1D_CameraArrowPointing[2] == false) && (gv__1D_CameraArrowPointing[3] == false) && (gv__1D_CameraArrowPointing[4] == false)) {
            gv__1D_DiabloFound = true;
            return true;
        }
        else {
        }
        Wait(0.125, c_timeGame);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1DCameraLocationLogic_Init () {
    gt__1DCameraLocationLogic = TriggerCreate("gt__1DCameraLocationLogic_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1D - Diablo Fight Q
//--------------------------------------------------------------------------------------------------
bool gt__1DDiabloFightQ_Func (bool testConds, bool runActions) {
    fixed auto3427D760_at;
    fixed auto020BA522_at;

    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerQueueEnter();
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
    libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00294", c_transmissionDurationAdd, 0.0, true, 1, 0);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
    TriggerExecute(gt_ObjectiveKillDiabloCreate, true, true);
    TriggerEnable(gt__1DDiabloFightBegin, true);
    TriggerEnable(gt__1DCameraSpacebarPressed, true);
    libStEx_gf_DisplayHintMessage(StringExternal("Param/Value/7E5083A0"), true, 1.5);
    while (true) {
        auto3427D760_at = 0;
        while (!((gv__1D_SpacebarPressed == true)) && auto3427D760_at <= 9.0) {
            Wait(1.0, c_timeGame);
            auto3427D760_at = auto3427D760_at + 1.0;
        }
        if ((gv__1D_SpacebarPressed == false)) {
            libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
            libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00295", c_transmissionDurationAdd, 0.0, true, 1, 0);
            libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
        }
        else {
            break;
        }
    }
    libNtve_gf_MakeUnitUncommandable(gv_hERO_Raynor, false);
    libNtve_gf_PauseUnit(gv_hERO_Raynor, false);
    gv__1D_CameraLockButtonClicked = false;
    TriggerEnable(gt__1DCameraUnlocked, true);
    TriggerEnable(gt__1DDiabloWon, true);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
    libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00296", c_transmissionDurationAdd, 0.0, true, 1, 0);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
    TriggerExecute(gt_AddReferenceCardCamera, true, false);
    TextExpressionSetToken("Param/Expression/ECD10D3C", "A", libStEx_gf_CameraLockHotkeyText());
    libStEx_gf_DisplayHintMessage(TextExpressionAssemble("Param/Expression/ECD10D3C"), true, 1.5);
    TriggerQueueExit();
    if ((gv__1D_DiabloFightBegan == false)) {
        TriggerExecute(gt__1DDiabloPing, true, false);
    }
    else {
    }
    auto020BA522_at = 0;
    while (!((gv__1D_CameraLockButtonClicked == true)) && auto020BA522_at <= 10.0) {
        Wait(0.5, c_timeGame);
        auto020BA522_at = auto020BA522_at + 0.5;
    }
    libStEx_gf_ClearHintMessage();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1DDiabloFightQ_Init () {
    gt__1DDiabloFightQ = TriggerCreate("gt__1DDiabloFightQ_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1D - Diablo Ping
//--------------------------------------------------------------------------------------------------
bool gt__1DDiabloPing_Func (bool testConds, bool runActions) {
    fixed auto470A0D3C_at;

    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    Wait(3.0, c_timeGame);
    while (true) {
        if ((gv__1D_DiabloFightBegan == true)) {
            return true;
        }
        else {
        }
        libNtve_gf_CreatePingFacingAngle(PlayerGroupAll(), "PingAlert", UnitGetPosition(gv_hERO_Diablo), ColorWithAlpha(100.00, 100.00, 0.00, 0.00), 5.0, 270.0);
        auto470A0D3C_at = 0;
        while (!((gv__1D_DiabloFightBegan == true)) && auto470A0D3C_at <= 10.0) {
            Wait(1.0, c_timeGame);
            auto470A0D3C_at = auto470A0D3C_at + 1.0;
        }
        PingDestroy(PingLastCreated());
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1DDiabloPing_Init () {
    gt__1DDiabloPing = TriggerCreate("gt__1DDiabloPing_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1D - Raynor Enter Diablo Banter Q
//--------------------------------------------------------------------------------------------------
bool gt__1DRaynorEnterDiabloBanterQ_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerQueueEnter();
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
    libCore_gf_SendTransmissionCampaign(gv_hERO_Diablo, "TutorialVO|Line00297", c_transmissionDurationAdd, 0.0, true, 1, 0);
    libCore_gf_SendTransmissionCampaign(gv_hERO_Raynor, "TutorialVO|Line00318", c_transmissionDurationAdd, 0.0, true, 1, 0);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1DRaynorEnterDiabloBanterQ_Init () {
    gt__1DRaynorEnterDiabloBanterQ = TriggerCreate("gt__1DRaynorEnterDiabloBanterQ_Func");
    TriggerAddEventUnitRegion(gt__1DRaynorEnterDiabloBanterQ, UnitRefFromVariable("gv_hERO_Raynor"), RegionFromId(24), true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1D - Raynor Enter Diablo Region Change
//--------------------------------------------------------------------------------------------------
bool gt__1DRaynorEnterDiabloRegionChange_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerEnable(TriggerGetCurrent(), false);
    RegionPlayableMapSet(RegionFromId(22));
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1DRaynorEnterDiabloRegionChange_Init () {
    gt__1DRaynorEnterDiabloRegionChange = TriggerCreate("gt__1DRaynorEnterDiabloRegionChange_Func");
    TriggerAddEventUnitRegion(gt__1DRaynorEnterDiabloRegionChange, UnitRefFromVariable("gv_hERO_Raynor"), RegionFromId(31), true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1D - Raynor Enter Diablo Arena
//--------------------------------------------------------------------------------------------------
bool gt__1DRaynorEnterDiabloArena_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerEnable(TriggerGetCurrent(), false);
    UnitIssueOrder(gv_hERO_Diablo, OrderTargetingUnit(AbilityCommand("attack", 0), gv_hERO_Raynor), c_orderQueueReplace);
    TriggerEnable(gt__1DDiabloPenetratingRoundUsed, true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1DRaynorEnterDiabloArena_Init () {
    gt__1DRaynorEnterDiabloArena = TriggerCreate("gt__1DRaynorEnterDiabloArena_Func");
    TriggerAddEventUnitRegion(gt__1DRaynorEnterDiabloArena, UnitRefFromVariable("gv_hERO_Raynor"), RegionFromId(10), true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1D - Diablo Fight Begin
//--------------------------------------------------------------------------------------------------
bool gt__1DDiabloFightBegin_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerEnable(TriggerGetCurrent(), false);
    gv__1D_DiabloFightBegan = true;
    TriggerExecute(gt__1DDiabloAI, true, false);
    Wait(3.0, c_timeGame);
    if ((gv__1D_PenetratingRoundUsed == false)) {
        TriggerEnable(gt__1DDiabloPenetratingRoundTutorialRaynorDamaged, true);
    }
    else {
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1DDiabloFightBegin_Init () {
    gt__1DDiabloFightBegin = TriggerCreate("gt__1DDiabloFightBegin_Func");
    TriggerEnable(gt__1DDiabloFightBegin, false);
    TriggerAddEventUnitDamaged(gt__1DDiabloFightBegin, UnitRefFromVariable("gv_hERO_Raynor"), c_unitDamageTypeAny, c_unitDamageEither, null);
    TriggerAddEventUnitDamaged(gt__1DDiabloFightBegin, UnitRefFromVariable("gv_hERO_Diablo"), c_unitDamageTypeAny, c_unitDamageEither, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1D - Diablo Penetrating Round Used
//--------------------------------------------------------------------------------------------------
bool gt__1DDiabloPenetratingRoundUsed_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_scale;

    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    gv__1D_PenetratingRoundUsed = true;
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1DDiabloPenetratingRoundUsed_Init () {
    gt__1DDiabloPenetratingRoundUsed = TriggerCreate("gt__1DDiabloPenetratingRoundUsed_Func");
    TriggerEnable(gt__1DDiabloPenetratingRoundUsed, false);
    TriggerAddEventUnitAbility(gt__1DDiabloPenetratingRoundUsed, UnitRefFromVariable("gv_hERO_Raynor"), AbilityCommand("RaynorPenetratingRound", 0), c_abilEffectStageCast, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1D - Diablo AI
//--------------------------------------------------------------------------------------------------
bool gt__1DDiabloAI_Func (bool testConds, bool runActions) {
    // Variable Declarations
    fixed lv_distance;
    int lv_index;

    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    libNtve_gf_ShareVisionofUnit(gv_hERO_Raynor, true, gv_pLAYER_06_DIABLO);
    UnitIssueOrder(gv_hERO_Diablo, OrderTargetingUnit(AbilityCommand("attack", 0), gv_hERO_Raynor), c_orderQueueReplace);
    while (true) {
        if ((UnitIsAlive(gv_hERO_Diablo) == false) && (UnitIsAlive(gv_hERO_Raynor) == false)) {
            return true;
        }
        else {
        }
        lv_index += 1;
        if ((lv_index == 5)) {
            lv_index = 0;
            UnitIssueOrder(gv_hERO_Diablo, OrderTargetingUnit(AbilityCommand("attack", 0), gv_hERO_Raynor), c_orderQueueReplace);
            lv_index = 0;
        }
        else {
        }
        Wait(0.5, c_timeGame);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1DDiabloAI_Init () {
    gt__1DDiabloAI = TriggerCreate("gt__1DDiabloAI_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1D - Diablo Penetrating Round Tutorial Raynor Damaged
//--------------------------------------------------------------------------------------------------
bool gt__1DDiabloPenetratingRoundTutorialRaynorDamaged_Func (bool testConds, bool runActions) {
    // Variable Declarations
    fixed lv_distance;
    int lv_time;
    int lv_index;

    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }

        if (!((EventUnitDamageSourceUnit() == gv_hERO_Diablo))) {
            return false;
        }

        if (!((gv__1D_PenetratingRoundUsed == false))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerEnable(gt__1DDiabloPenetratingRoundTutorialUsed, true);
    UnitIssueOrder(gv_hERO_Raynor, Order(AbilityCommand("move", 2)), c_orderQueueReplace);
    UnitAbilityEnable(gv_hERO_Raynor, "move", false);
    UnitAbilityEnable(gv_hERO_Raynor, "attack", false);
    UnitAbilityEnable(gv_hERO_Raynor, "RaynorInspire", false);
    libNtve_gf_UnitRemoveCooldown(gv_hERO_Raynor, "Abil/RaynorPenetratingRound");
    UnitAbilityEnable(gv_hERO_Raynor, "RaynorPenetratingRound", true);
    libNtve_gf_PauseUnit(gv_hERO_Diablo, true);
    libNtve_gf_SendActorMessageToUnit(gv_hERO_Diablo, "AnimSetPausedAll");
    TriggerExecute(gt__1DDiabloPenetratingRoundTutorialQ, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1DDiabloPenetratingRoundTutorialRaynorDamaged_Init () {
    gt__1DDiabloPenetratingRoundTutorialRaynorDamaged = TriggerCreate("gt__1DDiabloPenetratingRoundTutorialRaynorDamaged_Func");
    TriggerEnable(gt__1DDiabloPenetratingRoundTutorialRaynorDamaged, false);
    TriggerAddEventUnitDamaged(gt__1DDiabloPenetratingRoundTutorialRaynorDamaged, UnitRefFromVariable("gv_hERO_Raynor"), c_unitDamageTypeAny, c_unitDamageEither, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1D - Diablo Penetrating Round Tutorial Q
//--------------------------------------------------------------------------------------------------
bool gt__1DDiabloPenetratingRoundTutorialQ_Func (bool testConds, bool runActions) {
    // Variable Declarations
    bool lv_targetGood;
    point lv_target;
    fixed lv_angle;
    int lv_index;

    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerQueueEnter();
    if ((gv__1D_PenetratingRoundUsed == true)) {
        return true;
    }
    else {
    }
    gv__1D_PenetratingRoundTutorialDone = true;
    UISetButtonHighlighted(PlayerGroupAll(), AbilityCommand("RaynorPenetratingRound", 0), true);
    libStEx_gf_HighlightCommandButton(true, 1);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
    libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00311", c_transmissionDurationAdd, 0.0, true, 1, 0);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
    if ((gv__1D_PenetratingRoundUsed == true)) {
        return true;
    }
    else {
    }
    libCore_gf_AttachReticleEffectAndTextTagOnUnit(2, 1, StringToText(""), gv_hERO_Diablo, "Ref_Center");
    libCore_gf_StoreActorForUnit(gv_hERO_Diablo, 1, libNtve_gf_ActorLastCreated());
    TextExpressionSetToken("Param/Expression/9E849100", "A", StringExternal("Param/Value/3EA36A9E"));
    TextExpressionSetToken("Param/Expression/9E849100", "B", libStEx_gf_HotkeyProfile_MouseButtonImageStringTag(1, libStEx_gv_sEC_MouseButtonWidth, libStEx_gv_sEC_MouseButtonHeight));
    libStEx_gf_DisplayHintMessage(TextExpressionAssemble("Param/Expression/9E849100"), true, 1.5);
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1DDiabloPenetratingRoundTutorialQ_Init () {
    gt__1DDiabloPenetratingRoundTutorialQ = TriggerCreate("gt__1DDiabloPenetratingRoundTutorialQ_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1D - Diablo Penetrating Round Tutorial Used
//--------------------------------------------------------------------------------------------------
bool gt__1DDiabloPenetratingRoundTutorialUsed_Func (bool testConds, bool runActions) {
    int auto1CC0CFD5_n;
    int auto1CC0CFD5_i;

    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerStop(gt__1DDiabloPenetratingRoundTutorialRaynorDamaged);
    TransmissionClearAll();
    libStEx_gf_HighlightCommandButton(false, 1);
    libStEx_gf_ClearHintMessage();
    gv__1D_PenetratingRoundUsed = true;
    libNtve_gf_PauseUnit(gv_hERO_Diablo, false);
    libNtve_gf_SendActorMessageToUnit(gv_hERO_Diablo, "AnimSetPausedAll 0");
    UnitAbilityEnable(gv_hERO_Raynor, "move", true);
    UnitAbilityEnable(gv_hERO_Raynor, "attack", true);
    UnitAbilityEnable(gv_hERO_Raynor, "RaynorInspire", true);
    if ((libCore_gf_ActorStoredForUnit(gv_hERO_Diablo, 1) != null)) {
        libNtve_gf_KillModel(libCore_gf_ActorStoredForUnit(gv_hERO_Diablo, 1));
        libCore_gf_StoreActorForUnit(gv_hERO_Diablo, 1, null);
    }
    else {
    }
    Wait(1.0, c_timeGame);
    auto1CC0CFD5_n = 3;
    for (auto1CC0CFD5_i = 1; auto1CC0CFD5_i <= auto1CC0CFD5_n; auto1CC0CFD5_i += 1) {
        UnitIssueOrder(gv_hERO_Diablo, OrderTargetingUnit(AbilityCommand("attack", 0), gv_hERO_Raynor), c_orderQueueReplace);
        Wait(1.0, c_timeGame);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1DDiabloPenetratingRoundTutorialUsed_Init () {
    gt__1DDiabloPenetratingRoundTutorialUsed = TriggerCreate("gt__1DDiabloPenetratingRoundTutorialUsed_Func");
    TriggerEnable(gt__1DDiabloPenetratingRoundTutorialUsed, false);
    TriggerAddEventUnitAbility(gt__1DDiabloPenetratingRoundTutorialUsed, UnitRefFromVariable("gv_hERO_Raynor"), AbilityCommand("RaynorPenetratingRound", 0), c_abilEffectStageCast, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 1D - Diablo Won
//--------------------------------------------------------------------------------------------------
bool gt__1DDiabloWon_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((UnitGetPropertyFixed(gv_hERO_Diablo, c_unitPropLife, c_unitPropCurrent) <= 85.0))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerStop(gt__1DDiabloAI);
    libNtve_gf_ChangeUnitDamage(gv_hERO_Diablo, 0, 1);
    libNtve_gf_PauseUnit(gv_hERO_Diablo, true);
    libNtve_gf_PlayAnimation(libNtve_gf_MainActorofUnit(gv_hERO_Diablo), c_animNameDefault, "Spell C", c_animFlagPlayForever | c_animFlagNonLooping, c_animTimeDefault);
    UnitSetPropertyFixed(gv_hERO_Diablo, c_unitPropLife, 1.0);
    TriggerQueueEnter();
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
    libCore_gf_SendTransmissionCampaign(gv_hERO_Diablo, "TutorialVO|Line00298", c_transmissionDurationAdd, 0.0, false, 1, 0);
    Wait(0.5, c_timeGame);
    UnitKill(gv_hERO_Diablo);
    TransmissionWait(TransmissionLastSent(), 0.0);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
    TriggerExecute(gt_ObjectiveKillDiabloComplete, true, false);
    Wait(2.0, c_timeGame);
    TriggerQueueExit();
    TriggerExecute(gt__2ATeleportBaseQ, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__1DDiabloWon_Init () {
    gt__1DDiabloWon = TriggerCreate("gt__1DDiabloWon_Func");
    TriggerEnable(gt__1DDiabloWon, false);
    TriggerAddEventUnitProperty(gt__1DDiabloWon, UnitRefFromVariable("gv_hERO_Diablo"), c_unitPropLife);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2A - TeleportBase Q
//--------------------------------------------------------------------------------------------------
bool gt__2ATeleportBaseQ_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerQueueEnter();
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
    libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00355", c_transmissionDurationAdd, 0.0, true, 1, 0);
    libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00299", c_transmissionDurationAdd, 0.0, true, 1, 0);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
    TriggerEnable(gt__2ATeleportBaseStarted, true);
    TriggerEnable(libGDHL_gt_HeroPortBackToBase, false);
    UnitAbilityShow(gv_hERO_Raynor, "PortBackToBase", true);
    libStEx_gf_HighlightCommandButton(true, 5);
    TriggerEnable(libGDHL_gt_HeroPortBackToBase, false);
    TriggerExecute(gt_ObjectiveBacktoBaseCreate, true, true);
    if ((gv__2A_TeleportStarted == false)) {
        TextExpressionSetToken("Param/Expression/34142EF0", "A", StringExternal("Param/Value/1026DC80"));
        libStEx_gf_DisplayHintMessage(TextExpressionAssemble("Param/Expression/34142EF0"), true, 1.5);
    }
    else {
    }
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2ATeleportBaseQ_Init () {
    gt__2ATeleportBaseQ = TriggerCreate("gt__2ATeleportBaseQ_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2A - TeleportBase Started
//--------------------------------------------------------------------------------------------------
bool gt__2ATeleportBaseStarted_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    gv__2A_TeleportStarted = true;
    libStEx_gf_ClearHintMessage();
    libStEx_gf_HighlightCommandButton(false, 5);
    TriggerEnable(gt__2ATeleportBaseCanceled, true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2ATeleportBaseStarted_Init () {
    gt__2ATeleportBaseStarted = TriggerCreate("gt__2ATeleportBaseStarted_Func");
    TriggerEnable(gt__2ATeleportBaseStarted, false);
    TriggerAddEventUnitAbility(gt__2ATeleportBaseStarted, UnitRefFromVariable("gv_hERO_Raynor"), AbilityCommand("PortBackToBase", 0), c_abilEffectStageCast, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2A - TeleportBase Canceled
//--------------------------------------------------------------------------------------------------
bool gt__2ATeleportBaseCanceled_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    gv__2A_TeleportStarted = false;
    libStEx_gf_ClearHintMessage();
    TextExpressionSetToken("Param/Expression/A1A3CD49", "A", StringExternal("Param/Value/DC627D6F"));
    libStEx_gf_DisplayHintMessage(TextExpressionAssemble("Param/Expression/A1A3CD49"), true, 1.5);
    TriggerEnable(gt__2ATeleportBaseStarted, true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2ATeleportBaseCanceled_Init () {
    gt__2ATeleportBaseCanceled = TriggerCreate("gt__2ATeleportBaseCanceled_Func");
    TriggerAddEventUnitAbility(gt__2ATeleportBaseCanceled, UnitRefFromVariable("gv_hERO_Raynor"), AbilityCommand("PortBackToBase", 0), c_unitAbilStageCancel, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2A - TeleportBase Completed
//--------------------------------------------------------------------------------------------------
bool gt__2ATeleportBaseCompleted_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerEnable(gt__2ATeleportBaseStarted, false);
    TriggerEnable(gt__2ATeleportBaseCanceled, false);
    libNtve_gf_MakeUnitUncommandable(gv_hERO_Raynor, true);
    libNtve_gf_ShowHideUnit(gv_hERO_Raynor, false);
    libNtve_gf_MakeUnitUncommandable(gv_hERO_Raynor, true);
    TriggerExecute(gt_ObjectiveBacktoBaseComplete, true, false);
    Wait(2.0, c_timeGame);
    TriggerEnable(libGDHL_gt_HeroPortBackToBase, true);
    TriggerEnable(gt__1_RaynorWontDie, false);
    TriggerEnable(libGame_gt_HeroDeathHeroDies, true);
    TriggerExecute(gt_MidGarrisonQ, true, true);
    TriggerExecute(gt__2BTownStart, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2ATeleportBaseCompleted_Init () {
    gt__2ATeleportBaseCompleted = TriggerCreate("gt__2ATeleportBaseCompleted_Func");
    TriggerAddEventUnitAbility(gt__2ATeleportBaseCompleted, UnitRefFromVariable("gv_hERO_Raynor"), AbilityCommand("PortBackToBase", 0), c_abilEffectStageFinish, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Minion - Spawn Cycle (Tutorial Order)
//--------------------------------------------------------------------------------------------------
bool gt_MinionSpawnCycleTutorialOrder_Func (bool testConds, bool runActions) {
    int autoD0000A54_ae;
    int autoD0000A54_ai;

    // Variable Declarations
    int lv_i;
    int lv_lane;
    fixed lv_remainingWaitTime;
    int lv_waveComposition;

    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    while (true) {
        if (((libGame_gv_gameOver == true))) {
            return true;
        }
        else {
        }
        while (!((gv_minion_SpawnPaused == false))) {
            Wait(1.0, c_timeGame);
        }
        libGame_gv_minionWaveSpawnCounter += 1;
        lv_waveComposition = libGame_gf_MinionDetermineWaveComposition();
        autoD0000A54_ae = libGame_gv_laneCount;
        autoD0000A54_ai = 1;
        lv_lane = 1;
        for ( ; ( (autoD0000A54_ai >= 0 && lv_lane <= autoD0000A54_ae) || (autoD0000A54_ai <= 0 && lv_lane >= autoD0000A54_ae) ) ; lv_lane += autoD0000A54_ai ) {
            if ((libGame_gv_laneData[lv_lane].lv_minionSpawningEnabled == true)) {
                while (!((gv_minion_SpawnPaused == false))) {
                    Wait(0.25, c_timeGame);
                }
                libGame_gf_MinionSpawnWave(lv_lane, libCore_gv_cOMPUTER_TeamOrder, lv_waveComposition);
                Wait(0.1875, c_timeGame);
            }
            else {
            }
        }
        Wait(22.0, c_timeAI);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_MinionSpawnCycleTutorialOrder_Init () {
    gt_MinionSpawnCycleTutorialOrder = TriggerCreate("gt_MinionSpawnCycleTutorialOrder_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Minion - Spawn Cycle (Tutorial Chaos)
//--------------------------------------------------------------------------------------------------
bool gt_MinionSpawnCycleTutorialChaos_Func (bool testConds, bool runActions) {
    int autoE605781F_ae;
    int autoE605781F_ai;

    // Variable Declarations
    int lv_i;
    int lv_lane;
    fixed lv_remainingWaitTime;
    int lv_waveComposition;

    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    while (true) {
        if (((libGame_gv_gameOver == true))) {
            return true;
        }
        else {
        }
        while (!((gv_minion_SpawnPaused == false))) {
            Wait(1.0, c_timeGame);
        }
        libGame_gv_minionWaveSpawnCounter += 1;
        lv_waveComposition = libGame_gf_MinionDetermineWaveComposition();
        autoE605781F_ae = libGame_gv_laneCount;
        autoE605781F_ai = 1;
        lv_lane = 1;
        for ( ; ( (autoE605781F_ai >= 0 && lv_lane <= autoE605781F_ae) || (autoE605781F_ai <= 0 && lv_lane >= autoE605781F_ae) ) ; lv_lane += autoE605781F_ai ) {
            if ((libGame_gv_laneData[lv_lane].lv_minionSpawningEnabled == true)) {
                while (!((gv_minion_SpawnPaused == false))) {
                    Wait(0.25, c_timeGame);
                }
                libGame_gf_MinionSpawnWave(lv_lane, libCore_gv_cOMPUTER_TeamChaos, lv_waveComposition);
                Wait(0.1875, c_timeGame);
            }
            else {
            }
        }
        Wait(35.0, c_timeAI);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_MinionSpawnCycleTutorialChaos_Init () {
    gt_MinionSpawnCycleTutorialChaos = TriggerCreate("gt_MinionSpawnCycleTutorialChaos_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Minion - Scaling
//--------------------------------------------------------------------------------------------------
bool gt_MinionScaling_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((UnitGetOwner(EventUnitCreatedUnit()) == gv_pLAYER_11_ORDER))) {
            return false;
        }

        if (!((UnitFilterMatch(EventUnitCreatedUnit(), gv_pLAYER_01_USER, UnitFilter((1 << c_targetFilterBiological), 0, 0, 0)) == true))) {
            return false;
        }
    }

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

    UnitBehaviorAddPlayer(EventUnitCreatedUnit(), "TutorialMinionScaling", gv_pLAYER_01_USER, 1);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_MinionScaling_Init () {
    gt_MinionScaling = TriggerCreate("gt_MinionScaling_Func");
    TriggerEnable(gt_MinionScaling, false);
    TriggerAddEventUnitCreated(gt_MinionScaling, null, null, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2 - Remove Enemy Globe
//--------------------------------------------------------------------------------------------------
bool gt__2RemoveEnemyGlobe_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((UnitGetType(EventUnitCreatedUnit()) == "RegenGlobe"))) {
            return false;
        }

        if (!((UnitGetOwner(EventUnitCreatedUnit()) == gv_pLAYER_12_CHAOS))) {
            return false;
        }
    }

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

    UnitRemove(EventUnitCreatedUnit());
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2RemoveEnemyGlobe_Init () {
    gt__2RemoveEnemyGlobe = TriggerCreate("gt__2RemoveEnemyGlobe_Func");
    TriggerEnable(gt__2RemoveEnemyGlobe, false);
    TriggerAddEventUnitCreated(gt__2RemoveEnemyGlobe, null, null, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2B - Town Start
//--------------------------------------------------------------------------------------------------
bool gt__2BTownStart_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    UnitSetPropertyFixed(gv__2B_Towers[1], c_unitPropLifeMax, 1500.0);
    UnitSetPropertyFixed(gv__2B_Towers[1], c_unitPropLife, 1500.0);
    UnitSetPropertyFixed(gv__2B_Towers[2], c_unitPropLifeMax, 1500.0);
    UnitSetPropertyFixed(gv__2B_Towers[2], c_unitPropLife, 1500.0);
    UnitSetPropertyFixed(UnitFromId(712), c_unitPropLifeMax, 1000.0);
    UnitSetPropertyFixed(UnitFromId(712), c_unitPropLife, 1000.0);
    UnitSetPropertyFixed(UnitFromId(707), c_unitPropLifeMax, 1000.0);
    UnitSetPropertyFixed(UnitFromId(707), c_unitPropLife, 1000.0);
    UnitSetPropertyFixed(UnitFromId(1543), c_unitPropLifeMax, 1500.0);
    UnitSetPropertyFixed(UnitFromId(1543), c_unitPropLife, 1500.0);
    UnitSetPropertyFixed(UnitFromId(918), c_unitPropLifeMax, 2000.0);
    UnitSetPropertyFixed(UnitFromId(918), c_unitPropLife, 2000.0);
    libGame_gv_heroDeath_UpdateStats = false;
    libGame_gv_heroDeath_RespawnMounted = false;
    libCore_gv_sYSUseEncouragementPanel = false;
    TriggerEnable(gt__2RemoveEnemyGlobe, true);
    TriggerEnable(gt_MinionScaling, true);
    TriggerExecute(gt_StormStartGame, true, false);
    TriggerQueueEnter();
    Wait(3.5, c_timeGame);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
    libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00305", c_transmissionDurationAdd, 0.0, true, 1, 0);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
    TriggerExecute(gt_ObjectiveMovetoFrontLineCreate, true, true);
    libNtve_gf_CreatePingFacingAngle(PlayerGroupAll(), "PingObjective", PointFromId(1213), ColorWithAlpha(0.00, 100.00, 0.00, 0.00), 0.0, 270.0);
    gv__2B_PingFrontLine = PingLastCreated();
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2BTownStart_Init () {
    gt__2BTownStart = TriggerCreate("gt__2BTownStart_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2B - Start Minion System
//--------------------------------------------------------------------------------------------------
bool gt__2BStartMinionSystem_Func (bool testConds, bool runActions) {
    int auto1787FDE6_ae;
    int auto1787FDE6_ai;

    // Variable Declarations
    int lv_composition;
    int lv_group;

    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    auto1787FDE6_ae = 3;
    auto1787FDE6_ai = 1;
    lv_composition = 1;
    for ( ; ( (auto1787FDE6_ai >= 0 && lv_composition <= auto1787FDE6_ae) || (auto1787FDE6_ai <= 0 && lv_composition >= auto1787FDE6_ae) ) ; lv_composition += auto1787FDE6_ai ) {
        lv_group = 0;
        lv_group += 1;
        libCore_gv_dataMinionWaveCompositions[lv_composition].lv_groupMinionType[lv_group] = 1;
        libCore_gv_dataMinionWaveCompositions[lv_composition].lv_groupMinionCount[lv_group] = 3;
        lv_group += 1;
        libCore_gv_dataMinionWaveCompositions[lv_composition].lv_groupMinionType[lv_group] = 2;
        libCore_gv_dataMinionWaveCompositions[lv_composition].lv_groupMinionCount[lv_group] = 1;
        lv_group += 1;
        libCore_gv_dataMinionWaveCompositions[lv_composition].lv_groupMinionType[lv_group] = 3;
        libCore_gv_dataMinionWaveCompositions[lv_composition].lv_groupMinionCount[lv_group] = 3;
        lv_group += 1;
        libCore_gv_dataMinionWaveCompositions[lv_composition].lv_groupMinionType[lv_group] = 6;
        libCore_gv_dataMinionWaveCompositions[lv_composition].lv_groupMinionCount[lv_group] = 1;
    }
    libGame_gf_MinionEnableDisableWaveCompositionType(false, 2);
    libGame_gf_MinionEnableDisableWaveCompositionType(false, 3);
    libGame_gf_MinionTurnMinionScalingOnOff(false);
    libCore_gv_sYSMinionAI = true;
    libGame_gf_MinionStartStopMinionSystem(true);
    libCore_gv_sYSMinionAI = false;
    libGame_gf_MinionStartStopMinionSpawnCycle(false);
    TriggerExecute(gt_MinionSpawnCycleTutorialOrder, true, false);
    TriggerExecute(gt_MinionSpawnCycleTutorialChaos, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2BStartMinionSystem_Init () {
    gt__2BStartMinionSystem = TriggerCreate("gt__2BStartMinionSystem_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2B - Tower Danger
//--------------------------------------------------------------------------------------------------
bool gt__2BTowerDanger_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerEnable(TriggerGetCurrent(), false);
    UnitIssueOrder(gv_hERO_Raynor, Order(AbilityCommand("move", 2)), c_orderQueueReplace);
    TriggerExecute(gt_MidTowerDangerQ, true, true);
    TriggerEnable(gt__2BMinionStrategyQ, true);
    TriggerEnable(gt__2BInDangerStrategyBeforeUtherJoins, true);
    TriggerEnable(gt__2BTowerStrategyQ, true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2BTowerDanger_Init () {
    gt__2BTowerDanger = TriggerCreate("gt__2BTowerDanger_Func");
    TriggerAddEventUnitRegion(gt__2BTowerDanger, UnitRefFromVariable("gv_hERO_Raynor"), RegionFromId(32), true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2B - In Danger Strategy (Before Uther Joins)
//--------------------------------------------------------------------------------------------------
bool gt__2BInDangerStrategyBeforeUtherJoins_Func (bool testConds, bool runActions) {
    // Variable Declarations
    fixed lv_lifePercent;

    // Variable Initialization

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

    lv_lifePercent = UnitGetPropertyFixed(gv_hERO_Raynor, c_unitPropLifePercent, c_unitPropCurrent);
    if ((lv_lifePercent <= 30.0)) {
        TriggerEnable(TriggerGetCurrent(), false);
        UnitCreateEffectUnit(gv_hERO_Instructor, "HolyLightCreateHealer", gv_hERO_Raynor);
        if ((TriggerQueueIsEmpty() == true)) {
            TriggerQueueEnter();
            libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
            libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00310", c_transmissionDurationAdd, 0.0, false, 1, 0);
            libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
            TriggerQueueExit();
        }
        else {
        }
        TriggerEnable(TriggerGetCurrent(), true);
    }
    else {
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2BInDangerStrategyBeforeUtherJoins_Init () {
    gt__2BInDangerStrategyBeforeUtherJoins = TriggerCreate("gt__2BInDangerStrategyBeforeUtherJoins_Func");
    TriggerEnable(gt__2BInDangerStrategyBeforeUtherJoins, false);
    TriggerAddEventUnitDamaged(gt__2BInDangerStrategyBeforeUtherJoins, UnitRefFromVariable("gv_hERO_Raynor"), c_unitDamageTypeAny, c_unitDamageEither, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2B - Minion Strategy Q
//--------------------------------------------------------------------------------------------------
bool gt__2BMinionStrategyQ_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_localHintIndex;

    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((gv__2_HintType != 1))) {
            return false;
        }

        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerExecute(gt_ObjectiveMovetoFrontLineComplete, true, false);
    PingDestroy(gv__2B_PingFrontLine);
    Wait(1.0, c_timeGame);
    TriggerQueueEnter();
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
    libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00250", c_transmissionDurationAdd, 0.0, true, 1, 0);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
    TriggerQueueExit();
    gf__2DisplayHintMessage(1);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2BMinionStrategyQ_Init () {
    gt__2BMinionStrategyQ = TriggerCreate("gt__2BMinionStrategyQ_Func");
    TriggerEnable(gt__2BMinionStrategyQ, false);
    TriggerAddEventUnitRegion(gt__2BMinionStrategyQ, UnitRefFromVariable("gv_hERO_Raynor"), RegionFromId(8), true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2B - Tower Strategy Q
//--------------------------------------------------------------------------------------------------
bool gt__2BTowerStrategyQ_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerEnable(gt__2BTowerTakesDamage, true);
    TriggerQueueEnter();
    libCore_gf_AttachReticleEffectAndTextTagOnUnit(2, 1, null, gv__2B_Towers[1], "Ref_Center");
    libCore_gf_StoreActorForUnit(gv__2B_Towers[1], 1, libNtve_gf_ActorLastCreated());
    libCore_gf_AttachReticleEffectAndTextTagOnUnit(2, 1, null, gv__2B_Towers[2], "Ref_Center");
    libCore_gf_StoreActorForUnit(gv__2B_Towers[2], 1, libNtve_gf_ActorLastCreated());
    UnitGroupLoopBegin(UnitGroup(null, gv_pLAYER_11_ORDER, RegionFromId(34), UnitFilter((1 << c_targetFilterBiological), 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0));
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        libNtve_gf_ChangeUnitDamage(UnitGroupLoopCurrent(), 0, 2);
    }
    UnitGroupLoopEnd();
    TriggerEnable(gt__2BTowerDiesQ, true);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
    libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00252", c_transmissionDurationAdd, 0.0, true, 1, 0);
    gf__2DisplayHintMessage(2);
    UnitBehaviorAddPlayer(gv__2B_Towers[1], "TownHallRecentlyAttacked", gv_pLAYER_01_USER, 1);
    UnitBehaviorAddPlayer(gv__2B_Towers[2], "TownHallRecentlyAttacked", gv_pLAYER_01_USER, 1);
    libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00253", c_transmissionDurationAdd, 0.0, true, 1, 0);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
    TriggerEnable(gt__2BTowerDamageQ, true);
    TriggerExecute(gt_ObjectiveKillEnemyTowersCreate, true, true);
    UnitGroupLoopBegin(UnitGroup(null, gv_pLAYER_11_ORDER, RegionFromId(34), UnitFilter((1 << c_targetFilterBiological), 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0));
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        libNtve_gf_ChangeUnitDamage(UnitGroupLoopCurrent(), 0, 0);
    }
    UnitGroupLoopEnd();
    TriggerQueueExit();
    TriggerEnable(gt__2CTakingDamageFromMinion, true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2BTowerStrategyQ_Init () {
    gt__2BTowerStrategyQ = TriggerCreate("gt__2BTowerStrategyQ_Func");
    TriggerEnable(gt__2BTowerStrategyQ, false);
    TriggerAddEventUnitRegion(gt__2BTowerStrategyQ, UnitRefFromVariable("gv_hERO_Raynor"), RegionFromId(9), true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2B - Tower Dies Q
//--------------------------------------------------------------------------------------------------
bool gt__2BTowerDiesQ_Func (bool testConds, bool runActions) {
    int init_i;

    // Variable Declarations
    bool[3] lv_towerAlive;

    // Variable Initialization
    for (init_i = 0; init_i <= 2; init_i += 1) {
        lv_towerAlive[init_i] = true;
    }

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

    gv__2B_TowerAlives = 2;
    if (((UnitIsAlive(gv__2B_Towers[1]) == false) || (UnitGetType(gv__2B_Towers[1]) == "TownCannonTowerDead"))) {
        lv_towerAlive[1] = false;
        if ((libCore_gf_ActorStoredForUnit(gv__2B_Towers[1], 1) != null)) {
            libNtve_gf_KillModel(libCore_gf_ActorStoredForUnit(gv__2B_Towers[1], 1));
            libCore_gf_StoreActorForUnit(gv__2B_Towers[1], 1, null);
        }
        else {
        }
        gv__2B_TowerAlives -= 1;
        TriggerExecute(gt_ObjectiveKillEnemyTowersUpdate, true, false);
    }
    else {
    }
    if (((UnitIsAlive(gv__2B_Towers[2]) == false) || (UnitGetType(gv__2B_Towers[2]) == "TownCannonTowerDead"))) {
        lv_towerAlive[2] = false;
        if ((libCore_gf_ActorStoredForUnit(gv__2B_Towers[2], 1) != null)) {
            libNtve_gf_KillModel(libCore_gf_ActorStoredForUnit(gv__2B_Towers[2], 1));
            libCore_gf_StoreActorForUnit(gv__2B_Towers[2], 1, null);
        }
        else {
        }
        gv__2B_TowerAlives -= 1;
        TriggerExecute(gt_ObjectiveKillEnemyTowersUpdate, true, false);
    }
    else {
    }
    if ((lv_towerAlive[1] == false) && (lv_towerAlive[2] == false)) {
        TriggerEnable(TriggerGetCurrent(), false);
        libNtve_gf_MakeUnitUncommandable(gv_hERO_Raynor, true);
        libNtve_gf_ChangeUnitDamage(gv_hERO_Raynor, 0, 1);
        TriggerEnable(gt__2CTakingDamageFromMinion, false);
        TriggerExecute(gt_ObjectiveKillEnemyTowersComplete, true, false);
        Wait(1.0, c_timeGame);
        UnitIssueOrder(gv_hERO_Raynor, Order(AbilityCommand("move", 2)), c_orderQueueReplace);
        TriggerExecute(gt__2BTowerDamageEscapeMoved, false, false);
        Wait(1.0, c_timeReal);
        if ((gv__2B_TowersEscapeTextTag != c_textTagNone)) {
            TextTagDestroy(gv__2B_TowersEscapeTextTag);
            gv__2B_TowersEscapeTextTag = c_textTagNone;
        }
        else {
        }
        TriggerExecute(gt_MidDeathQ, true, true);
        TriggerExecute(gt__2CFinalBattleStart, true, false);
    }
    else {
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2BTowerDiesQ_Init () {
    gt__2BTowerDiesQ = TriggerCreate("gt__2BTowerDiesQ_Func");
    TriggerEnable(gt__2BTowerDiesQ, false);
    TriggerAddEventTimePeriodic(gt__2BTowerDiesQ, 0.5, c_timeGame);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2B - Tower Damage Q
//--------------------------------------------------------------------------------------------------
bool gt__2BTowerDamageQ_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!(((EventUnitDamageSourceUnit() == UnitFromId(37)) || (EventUnitDamageSourceUnit() == UnitFromId(39))))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerExecute(gt__2BTowerDamageEscape, true, false);
    TransmissionClearAll();
    TriggerQueueEnter();
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
    libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00306", c_transmissionDurationAdd, 0.0, true, 1, 0);
    Wait(1.0, c_timeGame);
    gf__2DisplayHintMessage(2);
    if ((DistanceBetweenPoints(UnitGetPosition(gv_hERO_Raynor), UnitGetPosition(UnitFromId(37))) > 9.0) && (DistanceBetweenPoints(UnitGetPosition(gv_hERO_Raynor), UnitGetPosition(UnitFromId(39))) > 9.0)) {
        TransmissionWait(TransmissionLastSent(), 0.0);
        libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
        return true;
    }
    else {
    }
    TransmissionWait(TransmissionLastSent(), 0.0);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2BTowerDamageQ_Init () {
    gt__2BTowerDamageQ = TriggerCreate("gt__2BTowerDamageQ_Func");
    TriggerEnable(gt__2BTowerDamageQ, false);
    TriggerAddEventUnitDamaged(gt__2BTowerDamageQ, UnitRefFromVariable("gv_hERO_Raynor"), c_unitDamageTypeAny, c_unitDamageEither, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2B - Tower Takes Damage
//--------------------------------------------------------------------------------------------------
bool gt__2BTowerTakesDamage_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerEnable(TriggerGetCurrent(), false);
    while (true) {
        if ((UnitIsAlive(UnitFromId(37)) == false) && (UnitIsAlive(UnitFromId(39)) == false)) {
            return true;
        }
        else {
        }
        if ((DistanceBetweenPoints(UnitGetPosition(gv_hERO_Raynor), UnitGetPosition(UnitFromId(37))) > 12.0) && (DistanceBetweenPoints(UnitGetPosition(gv_hERO_Raynor), UnitGetPosition(UnitFromId(39))) > 12.0)) {
            libNtve_gf_ChangeUnitDamage(UnitFromId(1543), 0, 1);
        }
        else {
            libNtve_gf_ChangeUnitDamage(UnitFromId(1543), 0, 0);
        }
        Wait(0.25, c_timeGame);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2BTowerTakesDamage_Init () {
    gt__2BTowerTakesDamage = TriggerCreate("gt__2BTowerTakesDamage_Func");
    TriggerEnable(gt__2BTowerTakesDamage, false);
    TriggerAddEventUnitDamaged(gt__2BTowerTakesDamage, UnitRefFromUnit(UnitFromId(37)), c_unitDamageTypeAny, c_unitDamageEither, null);
    TriggerAddEventUnitDamaged(gt__2BTowerTakesDamage, UnitRefFromUnit(UnitFromId(39)), c_unitDamageTypeAny, c_unitDamageEither, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2B - Tower Damage Escape
//--------------------------------------------------------------------------------------------------
bool gt__2BTowerDamageEscape_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    gv_minion_SpawnPaused = true;
    libNtve_gf_ChangeUnitDamage(gv_hERO_Raynor, 0, 1);
    UnitPauseAll(true);
    gv__2B_TowersEscapeUnitsPaused = UnitGroupAlliance(c_playerAny, c_unitAllianceAnyExcludeSelf, RegionCircle(UnitGetPosition(gv_hERO_Raynor), 30.0), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    UnitGroupRemove(gv__2B_TowersEscapeUnitsPaused, gv_hERO_Raynor);
    UnitGroupLoopBegin(gv__2B_TowersEscapeUnitsPaused);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        libNtve_gf_SendActorMessageToUnit(UnitGroupLoopCurrent(), "AnimSetPausedAll");
    }
    UnitGroupLoopEnd();
    libNtve_gf_PauseUnit(gv_hERO_Raynor, false);
    UnitIssueOrder(gv_hERO_Raynor, Order(AbilityCommand("stop", 0)), c_orderQueueReplace);
    UnitAbilityEnable(gv_hERO_Raynor, "attack", false);
    UnitAbilityEnable(gv_hERO_Raynor, "RaynorInspire", false);
    UnitAbilityEnable(gv_hERO_Raynor, "RaynorPenetratingRound", false);
    UnitAbilityEnable(gv_hERO_Raynor, "PortBackToBase", false);
    UnitAbilityEnable(gv_hERO_Raynor, "Mount", false);
    gv__2B_TowerEscape = gf__2BTowerSuggestedEspacePosition(PointFromId(1232), PointFromId(1233), 11.0, UnitGetPosition(gv_hERO_Raynor));
    TriggerExecute(gt__2BTowerDamageEscapeReticleEffect, true, false);
    TriggerEnable(gt__2BTowerDamageEscapeWrong, true);
    TriggerEnable(gt__2BTowerDamageEscapeMoved, true);
    TriggerEnable(gt__2BTowerDamageEscapeReached, true);
    while (!((gf__2BTowerSuggestedEspacePositionGood(UnitGetPosition(gv_hERO_Raynor)) == true))) {
        Wait(0.5, c_timeGame);
    }
    TriggerExecute(gt__2BTowerDamageEscapeReached, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2BTowerDamageEscape_Init () {
    gt__2BTowerDamageEscape = TriggerCreate("gt__2BTowerDamageEscape_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2B - Tower Damage Escape Reticle Effect
//--------------------------------------------------------------------------------------------------
bool gt__2BTowerDamageEscapeReticleEffect_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    if ((gv__2B_TowersEscapeActor != null)) {
        libNtve_gf_KillModel(gv__2B_TowersEscapeActor);
        TextTagDestroy(gv__2B_TowersEscapeTextTag);
    }
    else {
    }
    libCore_gf_CreateReticleEffectAndTextTagAtPoint(0, 1, StringExternal("Param/Value/6CF34DE3"), gv__2B_TowerEscape);
    gv__2B_TowersEscapeActor = libNtve_gf_ActorLastCreated();
    gv__2B_TowersEscapeTextTag = TextTagLastCreated();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2BTowerDamageEscapeReticleEffect_Init () {
    gt__2BTowerDamageEscapeReticleEffect = TriggerCreate("gt__2BTowerDamageEscapeReticleEffect_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2B - Tower Damage Escape Transmission Q
//--------------------------------------------------------------------------------------------------
bool gt__2BTowerDamageEscapeTransmissionQ_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerQueueEnter();
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
    libCore_gf_SendTransmissionCampaign(null, "TutorialVO|Line00324", c_transmissionDurationAdd, 0.0, true, 1, 0);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
    TriggerQueueExit();
    TriggerEnable(TriggerGetCurrent(), true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2BTowerDamageEscapeTransmissionQ_Init () {
    gt__2BTowerDamageEscapeTransmissionQ = TriggerCreate("gt__2BTowerDamageEscapeTransmissionQ_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2B - Tower Damage Escape Wrong
//--------------------------------------------------------------------------------------------------
bool gt__2BTowerDamageEscapeWrong_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    if ((OrderGetTargetUnit(EventUnitOrder()) != null) && ((DistanceBetweenPoints(UnitGetPosition(OrderGetTargetUnit(EventUnitOrder())), gv__2B_TowerEscape) <= DistanceBetweenPoints(UnitGetPosition(gv_hERO_Raynor), gv__2B_TowerEscape)) || (gf__2BTowerSuggestedEspacePositionGood(UnitGetPosition(OrderGetTargetUnit(EventUnitOrder()))) == true))) {
        return true;
    }
    else {
    }
    if ((OrderGetTargetPoint(EventUnitOrder()) != null) && ((DistanceBetweenPoints(OrderGetTargetPoint(EventUnitOrder()), gv__2B_TowerEscape) <= DistanceBetweenPoints(UnitGetPosition(gv_hERO_Raynor), gv__2B_TowerEscape)) || (gf__2BTowerSuggestedEspacePositionGood(OrderGetTargetPoint(EventUnitOrder())) == true))) {
        return true;
    }
    else {
    }
    UnitIssueOrder(gv_hERO_Raynor, Order(AbilityCommand("stop", 0)), c_orderQueueReplace);
    TriggerExecute(gt__2BTowerDamageEscapeTransmissionQ, true, false);
    TriggerExecute(gt__2BTowerDamageEscapeReticleEffect, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2BTowerDamageEscapeWrong_Init () {
    gt__2BTowerDamageEscapeWrong = TriggerCreate("gt__2BTowerDamageEscapeWrong_Func");
    TriggerEnable(gt__2BTowerDamageEscapeWrong, false);
    TriggerAddEventUnitOrder(gt__2BTowerDamageEscapeWrong, UnitRefFromVariable("gv_hERO_Raynor"), AbilityCommand("move", 0));
    TriggerAddEventUnitOrder(gt__2BTowerDamageEscapeWrong, UnitRefFromVariable("gv_hERO_Raynor"), AbilityCommand("move", 3));
    TriggerAddEventUnitOrder(gt__2BTowerDamageEscapeWrong, UnitRefFromVariable("gv_hERO_Raynor"), AbilityCommand("attack", 0));
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2B - Tower Damage Escape Moved
//--------------------------------------------------------------------------------------------------
bool gt__2BTowerDamageEscapeMoved_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((OrderGetTargetPosition(EventUnitOrder()) != null))) {
            return false;
        }

        if (!((DistanceBetweenPoints(OrderGetTargetPoint(EventUnitOrder()), gv__2B_TowerEscape) <= 2.0))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    gv__2B_TowersEscapeOrderIssued = true;
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2BTowerDamageEscapeMoved_Init () {
    gt__2BTowerDamageEscapeMoved = TriggerCreate("gt__2BTowerDamageEscapeMoved_Func");
    TriggerEnable(gt__2BTowerDamageEscapeMoved, false);
    TriggerAddEventUnitOrder(gt__2BTowerDamageEscapeMoved, UnitRefFromVariable("gv_hERO_Raynor"), AbilityCommand("move", 0));
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2B - Tower Damage Escape Reached
//--------------------------------------------------------------------------------------------------
bool gt__2BTowerDamageEscapeReached_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    libNtve_gf_ChangeUnitDamage(gv_hERO_Raynor, 0, 0);
    TriggerEnable(gt__2BTowerDamageEscapeWrong, false);
    gv_minion_SpawnPaused = false;
    UnitPauseAll(false);
    UnitGroupLoopBegin(gv__2B_TowersEscapeUnitsPaused);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        libNtve_gf_SendActorMessageToUnit(UnitGroupLoopCurrent(), "AnimSetPausedAll 0");
    }
    UnitGroupLoopEnd();
    gv__2B_TowersEscapeOrderIssued = true;
    gv__2B_TowersEscapeEscaped = true;
    UnitAbilityEnable(gv_hERO_Raynor, "attack", true);
    UnitAbilityEnable(gv_hERO_Raynor, "RaynorInspire", true);
    UnitAbilityEnable(gv_hERO_Raynor, "RaynorPenetratingRound", true);
    UnitAbilityEnable(gv_hERO_Raynor, "PortBackToBase", true);
    UnitAbilityEnable(gv_hERO_Raynor, "Mount", true);
    if ((gv__2B_TowersEscapeActor != null)) {
        libNtve_gf_KillModel(gv__2B_TowersEscapeActor);
        gv__2B_TowersEscapeActor = null;
    }
    else {
    }
    if ((gv__2B_TowersEscapeTextTag != c_textTagNone)) {
        TextTagDestroy(gv__2B_TowersEscapeTextTag);
        gv__2B_TowersEscapeTextTag = c_textTagNone;
    }
    else {
    }
    Wait(1.0, c_timeGame);
    TriggerEnable(gt__2BTowerDamageEscapeMore, true);
    TriggerEnable(gt__2BTowerDamageEscape, true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2BTowerDamageEscapeReached_Init () {
    gt__2BTowerDamageEscapeReached = TriggerCreate("gt__2BTowerDamageEscapeReached_Func");
    TriggerEnable(gt__2BTowerDamageEscapeReached, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2B - Tower Damage Escape More
//--------------------------------------------------------------------------------------------------
bool gt__2BTowerDamageEscapeMore_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!(((EventUnitDamageSourceUnit() == UnitFromId(37)) || (EventUnitDamageSourceUnit() == UnitFromId(39))))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerExecute(gt__2BTowerDamageEscape, true, false);
    TransmissionClearAll();
    TriggerQueueEnter();
    gf__2DisplayHintMessage(2);
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2BTowerDamageEscapeMore_Init () {
    gt__2BTowerDamageEscapeMore = TriggerCreate("gt__2BTowerDamageEscapeMore_Func");
    TriggerEnable(gt__2BTowerDamageEscapeMore, false);
    TriggerAddEventUnitDamaged(gt__2BTowerDamageEscapeMore, UnitRefFromVariable("gv_hERO_Raynor"), c_unitDamageTypeAny, c_unitDamageEither, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2C - Final Battle Start
//--------------------------------------------------------------------------------------------------
bool gt__2CFinalBattleStart_Func (bool testConds, bool runActions) {
    int auto9105F77C_n;
    int auto9105F77C_i;

    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerEnable(gt__2CCustomizedHeroDeathTimer, true);
    TriggerEnable(gt__2BInDangerStrategyBeforeUtherJoins, false);
    TriggerEnable(gt__2CTakingDamageFromMinion, true);
    TriggerEnable(gt__2CMountTutorialQ, true);
    TriggerEnable(gt__2CFortApproached, true);
    TriggerEnable(gt__2CFortDamage, true);
    TriggerEnable(gt__2CFortTakesDamage, true);
    TriggerEnable(gt__2CPalaceDamage, true);
    TriggerEnable(gt__2CPalaceTakesDamage, true);
    TriggerEnable(gt__2CPalaceDied, true);
    libGame_gv_heroDeath_UpdateStats = true;
    UnitSetPropertyFixed(UnitFromId(37), c_unitPropEnergyPercent, 100.0);
    UnitSetPropertyFixed(UnitFromId(39), c_unitPropEnergyPercent, 100.0);
    libNtve_gf_ChangeUnitDamage(UnitFromId(40), 0, 1);
    UnitStatusBarOverride(UnitFromId(40), -1);
    libNtve_gf_ChangeUnitDamage(UnitFromId(110), 0, 1);
    UnitStatusBarOverride(UnitFromId(110), -1);
    libNtve_gf_ChangeUnitDamage(UnitFromId(1546), 0, 1);
    UnitStatusBarOverride(UnitFromId(1546), -1);
    UnitSetPropertyFixed(gv_hERO_Stitch, c_unitPropMovementSpeed, 3.5);
    UnitSetPropertyFixed(gv_hERO_Diablo, c_unitPropMovementSpeed, 3.5);
    Wait(5.0, c_timeGame);
    TriggerExecute(gt__2CUtherJoins, true, false);
    auto9105F77C_n = 7;
    for (auto9105F77C_i = 1; auto9105F77C_i <= auto9105F77C_n; auto9105F77C_i += 1) {
        if ((gv__2C_MountUsed == true)) {
            return true;
        }
        else {
        }
        if ((DistanceBetweenPoints(UnitGetPosition(gv_hERO_Raynor), UnitGetPosition(gv_hERO_Instructor)) > 8.0)) {
            libAIAI_gf_HeroAIDisableAIForPlayer(gv_pLAYER_02_UTHER);
            UnitIssueOrder(gv_hERO_Instructor, Order(AbilityCommand("stop", 0)), c_orderQueueReplace);
        }
        else {
        }
        Wait(1.0, c_timeGame);
    }
    TriggerExecute(gt__2CMountTutorialQ, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2CFinalBattleStart_Init () {
    gt__2CFinalBattleStart = TriggerCreate("gt__2CFinalBattleStart_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2C - Customized Hero Death Timer
//--------------------------------------------------------------------------------------------------
bool gt__2CCustomizedHeroDeathTimer_Func (bool testConds, bool runActions) {
    int auto37BDE516_val;

    // Variable Declarations
    fixed lv_deathTime;

    // Variable Initialization

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

    auto37BDE516_val = libGame_gf_HeroKilledPlayer();
    if (auto37BDE516_val == gv_pLAYER_01_USER) {
        lv_deathTime = 6.0;
    }
    else if (auto37BDE516_val == gv_pLAYER_02_UTHER) {
        lv_deathTime = 10.0;
    }
    else if (auto37BDE516_val == gv_pLAYER_06_DIABLO) {
        lv_deathTime = 50.0;
    }
    else if (auto37BDE516_val == gv_pLAYER_07_STITCHES) {
        lv_deathTime = 50.0;
    }
    else {
        return true;
    }
    TimerStart(libGame_gv_players[libGame_gf_HeroKilledPlayer()].lv_respawnTimer, lv_deathTime, false, c_timeGame);
    if ((libGame_gf_HeroKilledPlayer() == gv_pLAYER_01_USER)) {
        UnitBehaviorSetDuration(gv_hERO_Raynor, "Dead", TimerGetRemaining(libGame_gv_players[gv_pLAYER_01_USER].lv_respawnTimer));
        libUIUI_gf_HeroConsoleUnitStatusBarsUpdateStunDeathBar("Dead", gv_hERO_Raynor);
    }
    else {
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2CCustomizedHeroDeathTimer_Init () {
    gt__2CCustomizedHeroDeathTimer = TriggerCreate("gt__2CCustomizedHeroDeathTimer_Func");
    TriggerEnable(gt__2CCustomizedHeroDeathTimer, false);
    libGame_gf_HeroKilled(gt__2CCustomizedHeroDeathTimer);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2C - Mount Tutorial Q
//--------------------------------------------------------------------------------------------------
bool gt__2CMountTutorialQ_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerQueueEnter();
    TriggerEnable(gt__2CMountUsed, true);
    libAIAI_gf_HeroAIDisableAIForPlayer(gv_pLAYER_02_UTHER);
    UnitIssueOrder(gv_hERO_Instructor, Order(AbilityCommand("stop", 0)), c_orderQueueReplace);
    TriggerEnable(gt__2CMountAway, true);
    TriggerEnable(gt__2CMountNoLongerNeeded, true);
    UnitAbilityShow(gv_hERO_Raynor, "Mount", true);
    UnitAbilityShow(gv_hERO_Raynor, "Dismount", true);
    libStEx_gf_HighlightCommandButton(true, 6);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
    libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00302", c_transmissionDurationAdd, 0.0, true, 1, 0);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
    TriggerExecute(gt_ObjectiveMountUpCreate, true, true);
    if ((gv__2C_MountUsed == false)) {
        TextExpressionSetToken("Param/Expression/E945ACFC", "A", StringExternal("Param/Value/E770E6DD"));
        libStEx_gf_DisplayHintMessage(TextExpressionAssemble("Param/Expression/E945ACFC"), true, 1.5);
    }
    else {
    }
    TriggerQueueExit();
    Wait(10.0, c_timeGame);
    libStEx_gf_ClearHintMessage();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2CMountTutorialQ_Init () {
    gt__2CMountTutorialQ = TriggerCreate("gt__2CMountTutorialQ_Func");
    TriggerEnable(gt__2CMountTutorialQ, false);
    TriggerAddEventUnitRegion(gt__2CMountTutorialQ, UnitRefFromVariable("gv_hERO_Raynor"), RegionFromId(25), true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2C - Mount Away
//--------------------------------------------------------------------------------------------------
bool gt__2CMountAway_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    libAIAI_gf_HeroAIEnableAIForPlayer(gv_pLAYER_02_UTHER);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2CMountAway_Init () {
    gt__2CMountAway = TriggerCreate("gt__2CMountAway_Func");
    TriggerEnable(gt__2CMountAway, false);
    TriggerAddEventUnitRegion(gt__2CMountAway, UnitRefFromVariable("gv_hERO_Raynor"), RegionFromId(30), true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2C - Mount Used
//--------------------------------------------------------------------------------------------------
bool gt__2CMountUsed_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    libStEx_gf_ClearHintMessage();
    gv__2C_MountUsed = true;
    libGame_gv_heroDeath_RespawnMounted = false;
    TriggerEnable(gt__2CMountNoLongerNeeded, false);
    libStEx_gf_HighlightCommandButton(false, 6);
    TriggerExecute(gt_ObjectiveMountUpComplete, true, false);
    Wait(1.0, c_timeGame);
    TriggerExecute(gt__2CMountAway, true, false);
    Wait(2.0, c_timeGame);
    libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00376", c_transmissionDurationAdd, 0.0, true, 1, 0);
    TriggerEnable(gt__2CMountReminder, true);
    TriggerExecute(gt__2CFortApproached, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2CMountUsed_Init () {
    gt__2CMountUsed = TriggerCreate("gt__2CMountUsed_Func");
    TriggerEnable(gt__2CMountUsed, false);
    TriggerAddEventUnitAbility(gt__2CMountUsed, UnitRefFromVariable("gv_hERO_Raynor"), AbilityCommand("Mount", 0), c_abilEffectStageFinish, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2C - Mount No Longer Needed
//--------------------------------------------------------------------------------------------------
bool gt__2CMountNoLongerNeeded_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    libStEx_gf_HighlightCommandButton(false, 6);
    ObjectiveDestroy(gv_objectiveMountUp);
    libStEx_gf_ClearHintMessage();
    TriggerEnable(gt__2CMountUsed, false);
    TriggerEnable(gt__2CMountReminder, true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2CMountNoLongerNeeded_Init () {
    gt__2CMountNoLongerNeeded = TriggerCreate("gt__2CMountNoLongerNeeded_Func");
    TriggerEnable(gt__2CMountNoLongerNeeded, false);
    TriggerAddEventUnitRegion(gt__2CMountNoLongerNeeded, UnitRefFromVariable("gv_hERO_Raynor"), RegionFromId(35), true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2C - Mount Reminder
//--------------------------------------------------------------------------------------------------
bool gt__2CMountReminder_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((libNtve_gf_UnitInRegion(gv_hERO_Raynor, RegionFromId(25)) == true))) {
            return false;
        }

        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerQueueEnter();
    if ((UnitHasBehavior2(gv_hERO_Raynor, "Mounted") == true)) {
        return true;
    }
    else {
    }
    TriggerEnable(gt__2CMountReminderUsed, true);
    TriggerEnable(gt__2CMountReminderNoLongerNeeded, true);
    libStEx_gf_HighlightCommandButton(true, 6);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
    libCore_gf_SendTransmissionCampaign(null, "TutorialVO|Line00312", c_transmissionDurationAdd, 0.0, true, 1, 0);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2CMountReminder_Init () {
    gt__2CMountReminder = TriggerCreate("gt__2CMountReminder_Func");
    TriggerEnable(gt__2CMountReminder, false);
    TriggerAddEventTimePeriodic(gt__2CMountReminder, 0.5, c_timeGame);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2C - Mount Reminder Used
//--------------------------------------------------------------------------------------------------
bool gt__2CMountReminderUsed_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    libStEx_gf_HighlightCommandButton(false, 6);
    TriggerEnable(gt__2CMountReminderNoLongerNeeded, false);
    TriggerEnable(gt__2CMountReminder, true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2CMountReminderUsed_Init () {
    gt__2CMountReminderUsed = TriggerCreate("gt__2CMountReminderUsed_Func");
    TriggerEnable(gt__2CMountReminderUsed, false);
    TriggerAddEventUnitBehaviorChange(gt__2CMountReminderUsed, UnitRefFromVariable("gv_hERO_Raynor"), "Mounted", c_unitBehaviorChangeCreate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2C - Mount Reminder No Longer Needed
//--------------------------------------------------------------------------------------------------
bool gt__2CMountReminderNoLongerNeeded_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    libStEx_gf_HighlightCommandButton(false, 6);
    TriggerEnable(gt__2CMountReminderUsed, false);
    TriggerEnable(gt__2CMountReminder, true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2CMountReminderNoLongerNeeded_Init () {
    gt__2CMountReminderNoLongerNeeded = TriggerCreate("gt__2CMountReminderNoLongerNeeded_Func");
    TriggerEnable(gt__2CMountReminderNoLongerNeeded, false);
    TriggerAddEventUnitRegion(gt__2CMountReminderNoLongerNeeded, UnitRefFromVariable("gv_hERO_Raynor"), RegionFromId(35), true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2C - Fort Approached
//--------------------------------------------------------------------------------------------------
bool gt__2CFortApproached_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerExecute(gt_ObjectiveKillEnemyFortCreate, true, true);
    libNtve_gf_CreatePingFacingAngle(PlayerGroupAll(), "PingObjective", UnitGetPosition(UnitFromId(1543)), ColorWithAlpha(0.00, 100.00, 0.00, 0.00), 0.0, 270.0);
    libCore_gf_StorePingForUnit(UnitFromId(1543), 1, PingLastCreated());
    PingSetTooltip(PingLastCreated(), StringExternal("Param/Value/D146CAC5"));
    libCore_gf_AttachReticleEffectAndTextTagOnUnit(2, 1, null, UnitFromId(1543), "Ref_Center");
    libCore_gf_StoreActorForUnit(UnitFromId(1543), 1, libNtve_gf_ActorLastCreated());
    TriggerExecute(gt__2CUseAbilitiesStartTimer, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2CFortApproached_Init () {
    gt__2CFortApproached = TriggerCreate("gt__2CFortApproached_Func");
    TriggerEnable(gt__2CFortApproached, false);
    TriggerAddEventUnitRegion(gt__2CFortApproached, UnitRefFromVariable("gv_hERO_Raynor"), RegionFromId(42), true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2C - Fort Destoryed Q
//--------------------------------------------------------------------------------------------------
bool gt__2CFortDestoryedQ_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerEnable(TriggerGetCurrent(), false);
    libAIAI_gf_HeroAIEnableAIForPlayer(gv_pLAYER_06_DIABLO);
    libAIAI_gf_HeroAISetAIDifficultyLevel(gv_pLAYER_06_DIABLO, 1);
    PingDestroy(libCore_gf_PingStoredForUnit(EventUnit(), 1));
    libNtve_gf_KillModel(libCore_gf_ActorStoredForUnit(EventUnit(), 1));
    UnitBehaviorRemovePlayer(UnitFromId(918), "CoreInvulnerability", gv_pLAYER_01_USER, 1);
    TriggerQueueEnter();
    TriggerExecute(gt_ObjectiveKillEnemyFortComplete, true, false);
    Wait(1.0, c_timeGame);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
    libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00267", c_transmissionDurationAdd, 0.0, true, 1, 0);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
    TriggerExecute(gt_ObjectiveKillEnemyPalaceCreate, true, true);
    libNtve_gf_CreatePingFacingAngle(PlayerGroupAll(), "PingObjective", UnitGetPosition(libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_core), ColorWithAlpha(0.00, 100.00, 0.00, 0.00), 0.0, 270.0);
    libCore_gf_StorePingForUnit(libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_core, 1, PingLastCreated());
    PingSetTooltip(PingLastCreated(), StringExternal("Param/Value/0EAEAFBC"));
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2CFortDestoryedQ_Init () {
    gt__2CFortDestoryedQ = TriggerCreate("gt__2CFortDestoryedQ_Func");
    TriggerAddEventUnitDied(gt__2CFortDestoryedQ, UnitRefFromUnit(UnitFromId(1543)));
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2C - Fort Damage
//--------------------------------------------------------------------------------------------------
bool gt__2CFortDamage_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((EventUnitDamageSourceUnit() == UnitFromId(1543)))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TransmissionClearAll();
    TriggerExecute(gt__2CFortDamageEscape, true, false);
    TriggerQueueEnter();
    gf__2DisplayHintMessage(3);
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2CFortDamage_Init () {
    gt__2CFortDamage = TriggerCreate("gt__2CFortDamage_Func");
    TriggerEnable(gt__2CFortDamage, false);
    TriggerAddEventUnitDamaged(gt__2CFortDamage, UnitRefFromVariable("gv_hERO_Raynor"), c_unitDamageTypeAny, c_unitDamageEither, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2C - Fort Damage Escape
//--------------------------------------------------------------------------------------------------
bool gt__2CFortDamageEscape_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    libNtve_gf_ChangeUnitDamage(gv_hERO_Raynor, 0, 1);
    gv_minion_SpawnPaused = true;
    UnitPauseAll(true);
    gv__2C_FortEscapeUnitsPaused = UnitGroupAlliance(c_playerAny, c_unitAllianceAnyExcludeSelf, RegionCircle(UnitGetPosition(gv_hERO_Raynor), 30.0), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    UnitGroupRemove(gv__2C_FortEscapeUnitsPaused, gv_hERO_Raynor);
    UnitGroupLoopBegin(gv__2C_FortEscapeUnitsPaused);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        libNtve_gf_SendActorMessageToUnit(UnitGroupLoopCurrent(), "AnimSetPausedAll");
    }
    UnitGroupLoopEnd();
    libNtve_gf_PauseUnit(gv_hERO_Raynor, false);
    UnitIssueOrder(gv_hERO_Raynor, Order(AbilityCommand("stop", 0)), c_orderQueueReplace);
    UnitAbilityEnable(gv_hERO_Raynor, "attack", false);
    UnitAbilityEnable(gv_hERO_Raynor, "RaynorInspire", false);
    UnitAbilityEnable(gv_hERO_Raynor, "RaynorPenetratingRound", false);
    UnitAbilityEnable(gv_hERO_Raynor, "PortBackToBase", false);
    UnitAbilityEnable(gv_hERO_Raynor, "Mount", false);
    gv__2C_FortEscape = gf__2CFortSuggestedEspacePosition(UnitGetPosition(UnitFromId(1543)), 13.0, UnitGetPosition(gv_hERO_Raynor));
    TriggerExecute(gt__2CFortDamageEscapeReticleEffect, true, false);
    TriggerEnable(gt__2CFortDamageEscapeMoved, true);
    TriggerEnable(gt__2CFortDamageEscapeWrong, true);
    TriggerEnable(gt__2CFortDamageEscapeReached, true);
    TriggerExecute(gt__2CFortDamageEscapeTransmissionQ, true, false);
    while (!(((DistanceBetweenPoints(UnitGetPosition(gv_hERO_Raynor), UnitGetPosition(UnitFromId(1543))) > 12.0) || (UnitIsAlive(UnitFromId(1543)) == false)))) {
        Wait(1.0, c_timeGame);
    }
    TriggerExecute(gt__2CFortDamageEscapeReached, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2CFortDamageEscape_Init () {
    gt__2CFortDamageEscape = TriggerCreate("gt__2CFortDamageEscape_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2C - Fort Damage Escape Reticle Effect
//--------------------------------------------------------------------------------------------------
bool gt__2CFortDamageEscapeReticleEffect_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    if ((gv__2C_FortEscapeActor != null)) {
        libNtve_gf_KillModel(gv__2C_FortEscapeActor);
        TextTagDestroy(gv__2C_FortEscapeTextTag);
    }
    else {
    }
    libCore_gf_CreateReticleEffectAndTextTagAtPoint(0, 1, StringExternal("Param/Value/F6329523"), gv__2C_FortEscape);
    gv__2C_FortEscapeActor = libNtve_gf_ActorLastCreated();
    gv__2C_FortEscapeTextTag = TextTagLastCreated();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2CFortDamageEscapeReticleEffect_Init () {
    gt__2CFortDamageEscapeReticleEffect = TriggerCreate("gt__2CFortDamageEscapeReticleEffect_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2C - Fort Damage Escape Transmission Q
//--------------------------------------------------------------------------------------------------
bool gt__2CFortDamageEscapeTransmissionQ_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerQueueEnter();
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
    libCore_gf_SendTransmissionCampaign(null, "TutorialVO|Line00324", c_transmissionDurationAdd, 0.0, true, 1, 0);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
    TriggerQueueExit();
    TriggerEnable(TriggerGetCurrent(), true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2CFortDamageEscapeTransmissionQ_Init () {
    gt__2CFortDamageEscapeTransmissionQ = TriggerCreate("gt__2CFortDamageEscapeTransmissionQ_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2C - Fort Damage Escape Wrong
//--------------------------------------------------------------------------------------------------
bool gt__2CFortDamageEscapeWrong_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    if ((OrderGetTargetUnit(EventUnitOrder()) != null) && (DistanceBetweenPoints(UnitGetPosition(OrderGetTargetUnit(EventUnitOrder())), UnitGetPosition(UnitFromId(1543))) >= DistanceBetweenPoints(UnitGetPosition(gv_hERO_Raynor), UnitGetPosition(UnitFromId(1543))))) {
        return true;
    }
    else {
    }
    if ((OrderGetTargetPoint(EventUnitOrder()) != null) && (DistanceBetweenPoints(OrderGetTargetPoint(EventUnitOrder()), UnitGetPosition(UnitFromId(1543))) >= DistanceBetweenPoints(UnitGetPosition(gv_hERO_Raynor), UnitGetPosition(UnitFromId(1543))))) {
        return true;
    }
    else {
    }
    UnitIssueOrder(gv_hERO_Raynor, Order(AbilityCommand("stop", 0)), c_orderQueueReplace);
    TriggerExecute(gt__2CFortDamageEscapeTransmissionQ, true, false);
    TriggerExecute(gt__2CFortDamageEscapeReticleEffect, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2CFortDamageEscapeWrong_Init () {
    gt__2CFortDamageEscapeWrong = TriggerCreate("gt__2CFortDamageEscapeWrong_Func");
    TriggerEnable(gt__2CFortDamageEscapeWrong, false);
    TriggerAddEventUnitOrder(gt__2CFortDamageEscapeWrong, UnitRefFromVariable("gv_hERO_Raynor"), AbilityCommand("move", 0));
    TriggerAddEventUnitOrder(gt__2CFortDamageEscapeWrong, UnitRefFromVariable("gv_hERO_Raynor"), AbilityCommand("move", 3));
    TriggerAddEventUnitOrder(gt__2CFortDamageEscapeWrong, UnitRefFromVariable("gv_hERO_Raynor"), AbilityCommand("attack", 0));
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2C - Fort Damage Escape Moved
//--------------------------------------------------------------------------------------------------
bool gt__2CFortDamageEscapeMoved_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((OrderGetTargetPosition(EventUnitOrder()) != null))) {
            return false;
        }

        if (!((DistanceBetweenPoints(OrderGetTargetPoint(EventUnitOrder()), gv__2C_FortEscape) <= 2.0))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    gv__2C_FortEscapeOrderIssued = true;
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2CFortDamageEscapeMoved_Init () {
    gt__2CFortDamageEscapeMoved = TriggerCreate("gt__2CFortDamageEscapeMoved_Func");
    TriggerEnable(gt__2CFortDamageEscapeMoved, false);
    TriggerAddEventUnitOrder(gt__2CFortDamageEscapeMoved, UnitRefFromVariable("gv_hERO_Raynor"), AbilityCommand("move", 0));
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2C - Fort Damage Escape Reached
//--------------------------------------------------------------------------------------------------
bool gt__2CFortDamageEscapeReached_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    libNtve_gf_ChangeUnitDamage(gv_hERO_Raynor, 0, 0);
    TriggerEnable(gt__2CFortDamageEscapeWrong, false);
    gv_minion_SpawnPaused = false;
    UnitPauseAll(false);
    UnitGroupLoopBegin(gv__2C_FortEscapeUnitsPaused);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        libNtve_gf_SendActorMessageToUnit(UnitGroupLoopCurrent(), "AnimSetPausedAll 0");
    }
    UnitGroupLoopEnd();
    gv__2C_FortEscapeOrderIssued = true;
    gv__2C_FortEscapeEscaped = true;
    UnitAbilityEnable(gv_hERO_Raynor, "attack", true);
    UnitAbilityEnable(gv_hERO_Raynor, "RaynorInspire", true);
    UnitAbilityEnable(gv_hERO_Raynor, "RaynorPenetratingRound", true);
    UnitAbilityEnable(gv_hERO_Raynor, "PortBackToBase", true);
    UnitAbilityEnable(gv_hERO_Raynor, "Mount", true);
    if ((gv__2C_FortEscapeActor != null)) {
        libNtve_gf_KillModel(gv__2C_FortEscapeActor);
        gv__2C_FortEscapeActor = null;
    }
    else {
    }
    if ((gv__2C_FortEscapeTextTag != c_textTagNone)) {
        TextTagDestroy(gv__2C_FortEscapeTextTag);
        gv__2C_FortEscapeTextTag = c_textTagNone;
    }
    else {
    }
    Wait(1.0, c_timeGame);
    TriggerEnable(gt__2CFortDamage, true);
    TriggerEnable(gt__2CFortDamageEscape, true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2CFortDamageEscapeReached_Init () {
    gt__2CFortDamageEscapeReached = TriggerCreate("gt__2CFortDamageEscapeReached_Func");
    TriggerEnable(gt__2CFortDamageEscapeReached, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2C - Fort Takes Damage
//--------------------------------------------------------------------------------------------------
bool gt__2CFortTakesDamage_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerEnable(TriggerGetCurrent(), false);
    while (true) {
        if ((UnitIsAlive(UnitFromId(1543)) == false)) {
            return true;
        }
        else {
        }
        if ((DistanceBetweenPoints(UnitGetPosition(gv_hERO_Raynor), UnitGetPosition(UnitFromId(1543))) > 12.0)) {
            libNtve_gf_ChangeUnitDamage(UnitFromId(1543), 0, 1);
        }
        else {
            libNtve_gf_ChangeUnitDamage(UnitFromId(1543), 0, 0);
        }
        Wait(0.25, c_timeGame);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2CFortTakesDamage_Init () {
    gt__2CFortTakesDamage = TriggerCreate("gt__2CFortTakesDamage_Func");
    TriggerEnable(gt__2CFortTakesDamage, false);
    TriggerAddEventUnitDamaged(gt__2CFortTakesDamage, UnitRefFromUnit(UnitFromId(1543)), c_unitDamageTypeAny, c_unitDamageEither, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2C - Uther Joins
//--------------------------------------------------------------------------------------------------
bool gt__2CUtherJoins_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    libAIAI_gf_HeroAIEnableAIForPlayer(gv_pLAYER_02_UTHER);
    libAIAI_gf_HeroAISetAIDifficultyLevel(gv_pLAYER_02_UTHER, 2);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2CUtherJoins_Init () {
    gt__2CUtherJoins = TriggerCreate("gt__2CUtherJoins_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2C - Palace Damage
//--------------------------------------------------------------------------------------------------
bool gt__2CPalaceDamage_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((EventUnitDamageSourceUnit() == UnitFromId(918)))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TransmissionClearAll();
    TriggerExecute(gt__2CPalaceDamageEscape, true, false);
    TriggerQueueEnter();
    gf__2DisplayHintMessage(4);
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2CPalaceDamage_Init () {
    gt__2CPalaceDamage = TriggerCreate("gt__2CPalaceDamage_Func");
    TriggerEnable(gt__2CPalaceDamage, false);
    TriggerAddEventUnitDamaged(gt__2CPalaceDamage, UnitRefFromVariable("gv_hERO_Raynor"), c_unitDamageTypeAny, c_unitDamageEither, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2C - Palace Damage Escape
//--------------------------------------------------------------------------------------------------
bool gt__2CPalaceDamageEscape_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    libNtve_gf_ChangeUnitDamage(gv_hERO_Raynor, 0, 1);
    gv_minion_SpawnPaused = true;
    UnitPauseAll(true);
    gv__2C_PalaceEscapeUnitsPaused = UnitGroupAlliance(c_playerAny, c_unitAllianceAnyExcludeSelf, RegionCircle(UnitGetPosition(gv_hERO_Raynor), 30.0), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    UnitGroupRemove(gv__2C_PalaceEscapeUnitsPaused, gv_hERO_Raynor);
    UnitGroupLoopBegin(gv__2C_PalaceEscapeUnitsPaused);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        libNtve_gf_SendActorMessageToUnit(UnitGroupLoopCurrent(), "AnimSetPausedAll");
    }
    UnitGroupLoopEnd();
    libNtve_gf_PauseUnit(gv_hERO_Raynor, false);
    UnitIssueOrder(gv_hERO_Raynor, Order(AbilityCommand("stop", 0)), c_orderQueueReplace);
    UnitAbilityEnable(gv_hERO_Raynor, "attack", false);
    UnitAbilityEnable(gv_hERO_Raynor, "RaynorInspire", false);
    UnitAbilityEnable(gv_hERO_Raynor, "RaynorPenetratingRound", false);
    UnitAbilityEnable(gv_hERO_Raynor, "PortBackToBase", false);
    UnitAbilityEnable(gv_hERO_Raynor, "Mount", false);
    gv__2C_PalaceEscape = gf__2CPalaceSuggestedEspacePosition(UnitGetPosition(UnitFromId(918)), 14.0, UnitGetPosition(gv_hERO_Raynor));
    TriggerExecute(gt__2CPalaceDamageEscapeReticleEffect, true, false);
    TriggerEnable(gt__2CPalaceDamageEscapeMoved, true);
    TriggerEnable(gt__2CPalaceDamageEscapeWrong, true);
    TriggerEnable(gt__2CPalaceDamageEscapeReached, true);
    TriggerExecute(gt__2CPalaceDamageEscapeTransmissionQ, true, false);
    while (!(((DistanceBetweenPoints(UnitGetPosition(gv_hERO_Raynor), UnitGetPosition(UnitFromId(918))) > 13.0) || (UnitIsAlive(UnitFromId(918)) == false)))) {
        Wait(1.0, c_timeGame);
    }
    TriggerExecute(gt__2CPalaceDamageEscapeReached, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2CPalaceDamageEscape_Init () {
    gt__2CPalaceDamageEscape = TriggerCreate("gt__2CPalaceDamageEscape_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2C - Palace Damage Escape Reticle Effect
//--------------------------------------------------------------------------------------------------
bool gt__2CPalaceDamageEscapeReticleEffect_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    if ((gv__2C_PalaceEscapeActor != null)) {
        libNtve_gf_KillModel(gv__2C_PalaceEscapeActor);
        TextTagDestroy(gv__2C_PalaceEscapeTextTag);
    }
    else {
    }
    libCore_gf_CreateReticleEffectAndTextTagAtPoint(0, 1, StringExternal("Param/Value/3B7587F0"), gv__2C_PalaceEscape);
    gv__2C_PalaceEscapeActor = libNtve_gf_ActorLastCreated();
    gv__2C_PalaceEscapeTextTag = TextTagLastCreated();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2CPalaceDamageEscapeReticleEffect_Init () {
    gt__2CPalaceDamageEscapeReticleEffect = TriggerCreate("gt__2CPalaceDamageEscapeReticleEffect_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2C - Palace Damage Escape Transmission Q
//--------------------------------------------------------------------------------------------------
bool gt__2CPalaceDamageEscapeTransmissionQ_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerQueueEnter();
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
    libCore_gf_SendTransmissionCampaign(null, "TutorialVO|Line00324", c_transmissionDurationAdd, 0.0, true, 1, 0);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
    TriggerQueueExit();
    TriggerEnable(TriggerGetCurrent(), true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2CPalaceDamageEscapeTransmissionQ_Init () {
    gt__2CPalaceDamageEscapeTransmissionQ = TriggerCreate("gt__2CPalaceDamageEscapeTransmissionQ_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2C - Palace Damage Escape Wrong
//--------------------------------------------------------------------------------------------------
bool gt__2CPalaceDamageEscapeWrong_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    if ((OrderGetTargetPoint(EventUnitOrder()) != null) && (DistanceBetweenPoints(OrderGetTargetPoint(EventUnitOrder()), UnitGetPosition(UnitFromId(918))) >= DistanceBetweenPoints(UnitGetPosition(gv_hERO_Raynor), UnitGetPosition(UnitFromId(918))))) {
        return true;
    }
    else {
    }
    if ((OrderGetTargetUnit(EventUnitOrder()) != null) && (DistanceBetweenPoints(UnitGetPosition(OrderGetTargetUnit(EventUnitOrder())), UnitGetPosition(UnitFromId(918))) >= DistanceBetweenPoints(UnitGetPosition(gv_hERO_Raynor), UnitGetPosition(UnitFromId(918))))) {
        return true;
    }
    else {
    }
    UnitIssueOrder(gv_hERO_Raynor, Order(AbilityCommand("stop", 0)), c_orderQueueReplace);
    TriggerExecute(gt__2CPalaceDamageEscapeTransmissionQ, true, false);
    TriggerExecute(gt__2CPalaceDamageEscapeReticleEffect, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2CPalaceDamageEscapeWrong_Init () {
    gt__2CPalaceDamageEscapeWrong = TriggerCreate("gt__2CPalaceDamageEscapeWrong_Func");
    TriggerEnable(gt__2CPalaceDamageEscapeWrong, false);
    TriggerAddEventUnitOrder(gt__2CPalaceDamageEscapeWrong, UnitRefFromVariable("gv_hERO_Raynor"), AbilityCommand("move", 0));
    TriggerAddEventUnitOrder(gt__2CPalaceDamageEscapeWrong, UnitRefFromVariable("gv_hERO_Raynor"), AbilityCommand("move", 3));
    TriggerAddEventUnitOrder(gt__2CPalaceDamageEscapeWrong, UnitRefFromVariable("gv_hERO_Raynor"), AbilityCommand("attack", 0));
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2C - Palace Damage Escape Moved
//--------------------------------------------------------------------------------------------------
bool gt__2CPalaceDamageEscapeMoved_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((OrderGetTargetPosition(EventUnitOrder()) != null))) {
            return false;
        }

        if (!((DistanceBetweenPoints(OrderGetTargetPoint(EventUnitOrder()), gv__2C_PalaceEscape) <= 2.0))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    gv__2C_PalaceEscapeOrderIssued = true;
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2CPalaceDamageEscapeMoved_Init () {
    gt__2CPalaceDamageEscapeMoved = TriggerCreate("gt__2CPalaceDamageEscapeMoved_Func");
    TriggerEnable(gt__2CPalaceDamageEscapeMoved, false);
    TriggerAddEventUnitOrder(gt__2CPalaceDamageEscapeMoved, UnitRefFromVariable("gv_hERO_Raynor"), AbilityCommand("move", 0));
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2C - Palace Damage Escape Reached
//--------------------------------------------------------------------------------------------------
bool gt__2CPalaceDamageEscapeReached_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    libNtve_gf_ChangeUnitDamage(gv_hERO_Raynor, 0, 0);
    TriggerEnable(gt__2CPalaceDamageEscapeWrong, false);
    gv_minion_SpawnPaused = false;
    UnitPauseAll(false);
    UnitGroupLoopBegin(gv__2C_PalaceEscapeUnitsPaused);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        libNtve_gf_SendActorMessageToUnit(UnitGroupLoopCurrent(), "AnimSetPausedAll 0");
    }
    UnitGroupLoopEnd();
    gv__2C_PalaceEscapeOrderIssued = true;
    gv__2C_PalaceEscapeEscaped = true;
    UnitAbilityEnable(gv_hERO_Raynor, "attack", true);
    UnitAbilityEnable(gv_hERO_Raynor, "RaynorInspire", true);
    UnitAbilityEnable(gv_hERO_Raynor, "RaynorPenetratingRound", true);
    UnitAbilityEnable(gv_hERO_Raynor, "PortBackToBase", true);
    UnitAbilityEnable(gv_hERO_Raynor, "Mount", true);
    if ((gv__2C_PalaceEscapeActor != null)) {
        libNtve_gf_KillModel(gv__2C_PalaceEscapeActor);
        gv__2C_PalaceEscapeActor = null;
    }
    else {
    }
    if ((gv__2C_PalaceEscapeTextTag != c_textTagNone)) {
        TextTagDestroy(gv__2C_PalaceEscapeTextTag);
        gv__2C_PalaceEscapeTextTag = c_textTagNone;
    }
    else {
    }
    Wait(1.0, c_timeGame);
    TriggerEnable(gt__2CPalaceDamage, true);
    TriggerEnable(gt__2CPalaceDamageEscape, true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2CPalaceDamageEscapeReached_Init () {
    gt__2CPalaceDamageEscapeReached = TriggerCreate("gt__2CPalaceDamageEscapeReached_Func");
    TriggerEnable(gt__2CPalaceDamageEscapeReached, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2C - Palace Takes Damage
//--------------------------------------------------------------------------------------------------
bool gt__2CPalaceTakesDamage_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerEnable(TriggerGetCurrent(), false);
    while (true) {
        if ((UnitIsAlive(libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_core) == false)) {
            return true;
        }
        else {
        }
        if ((DistanceBetweenPoints(UnitGetPosition(gv_hERO_Raynor), UnitGetPosition(libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_core)) > 12.0)) {
            libNtve_gf_ChangeUnitDamage(libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_core, 0, 1);
        }
        else {
            libNtve_gf_ChangeUnitDamage(libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_core, 0, 0);
        }
        Wait(0.25, c_timeGame);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2CPalaceTakesDamage_Init () {
    gt__2CPalaceTakesDamage = TriggerCreate("gt__2CPalaceTakesDamage_Func");
    TriggerEnable(gt__2CPalaceTakesDamage, false);
    TriggerAddEventUnitDamaged(gt__2CPalaceTakesDamage, UnitRefFromUnit(UnitFromId(918)), c_unitDamageTypeAny, c_unitDamageEither, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2C - Palace Died
//--------------------------------------------------------------------------------------------------
bool gt__2CPalaceDied_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_player;
    int lv_i;
    unit lv_u;
    const fixed lv_cameraPanTime = 2.0;
    int lv_killingFaction;

    // Variable Initialization

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

    libGame_gf_MinionStartStopMinionSystem(false);
    TriggerEnable(libGame_gt_XPTrickle, false);
    lv_killingFaction = 0;
    libGame_gv_players[gv_pLAYER_01_USER].lv_victoryDefeat = c_gameOverVictory;
    libGame_gv_players[gv_pLAYER_11_ORDER].lv_victoryDefeat = c_gameOverVictory;
    libGame_gv_players[gv_pLAYER_06_DIABLO].lv_victoryDefeat = c_gameOverDefeat;
    libGame_gv_players[gv_pLAYER_06_DIABLO].lv_victoryDefeat = c_gameOverDefeat;
    UnitPauseAll(true);
    libNtve_gf_ChangeUnitDamage(gv_hERO_Raynor, 0, 1);
    libNtve_gf_ChangeUnitDamage(gv_hERO_Instructor, 0, 1);
    Wait(1.0, c_timeReal);
    TriggerExecute(gt_ObjectiveKillEnemyPalaceComplete, true, false);
    Wait(2.0, c_timeReal);
    TriggerExecute(gt_VictoryQ, true, true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2CPalaceDied_Init () {
    gt__2CPalaceDied = TriggerCreate("gt__2CPalaceDied_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2C - Taking Damage From Minion
//--------------------------------------------------------------------------------------------------
bool gt__2CTakingDamageFromMinion_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((UnitGetOwner(EventUnitDamageSourceUnit()) == gv_pLAYER_12_CHAOS))) {
            return false;
        }

        if (!((UnitFilterMatch(EventUnitDamageSourceUnit(), gv_pLAYER_01_USER, UnitFilter((1 << c_targetFilterBiological), 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)))) == true))) {
            return false;
        }
    }

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

    if ((TriggerQueueIsEmpty() == false)) {
        return true;
    }
    else {
    }
    gf__2DisplayHintMessage(1);
    TriggerExecute(gt__2CTakingDamageFromMinionTransmission, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2CTakingDamageFromMinion_Init () {
    gt__2CTakingDamageFromMinion = TriggerCreate("gt__2CTakingDamageFromMinion_Func");
    TriggerEnable(gt__2CTakingDamageFromMinion, false);
    TriggerAddEventUnitDamaged(gt__2CTakingDamageFromMinion, UnitRefFromVariable("gv_hERO_Raynor"), c_unitDamageTypeAny, c_unitDamageEither, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2C - Taking Damage From Minion Transmission
//--------------------------------------------------------------------------------------------------
bool gt__2CTakingDamageFromMinionTransmission_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    if ((TriggerQueueIsEmpty() == true)) {
        TriggerQueueEnter();
        libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
        libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00374", c_transmissionDurationAdd, 0.0, true, 1, 0);
        libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
        TriggerQueueExit();
    }
    else {
    }
    Wait(30.0, c_timeGame);
    TriggerEnable(TriggerGetCurrent(), true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2CTakingDamageFromMinionTransmission_Init () {
    gt__2CTakingDamageFromMinionTransmission = TriggerCreate("gt__2CTakingDamageFromMinionTransmission_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2C - Use Abilities Start Timer
//--------------------------------------------------------------------------------------------------
bool gt__2CUseAbilitiesStartTimer_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TimerStart(gv__2C_UseAbilityTimer, 30.0, false, c_timeGame);
    TriggerEnable(gt__2CUseAbilitiesUsed, true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2CUseAbilitiesStartTimer_Init () {
    gt__2CUseAbilitiesStartTimer = TriggerCreate("gt__2CUseAbilitiesStartTimer_Func");
    TriggerEnable(gt__2CUseAbilitiesStartTimer, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2C - Use Abilities Timer Expires
//--------------------------------------------------------------------------------------------------
bool gt__2CUseAbilitiesTimerExpires_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerQueueEnter();
    Wait(2.0, c_timeGame);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(1, PlayerGroupAll());
    libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00375", c_transmissionDurationAdd, 0.0, true, 1, 0);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
    TriggerQueueExit();
    TriggerExecute(gt__2CUseAbilitiesStartTimer, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2CUseAbilitiesTimerExpires_Init () {
    gt__2CUseAbilitiesTimerExpires = TriggerCreate("gt__2CUseAbilitiesTimerExpires_Func");
    TriggerEnable(gt__2CUseAbilitiesTimerExpires, false);
    TriggerAddEventTimer(gt__2CUseAbilitiesTimerExpires, gv__2C_UseAbilityTimer);
}

//--------------------------------------------------------------------------------------------------
// Trigger: 2C - Use Abilities Used
//--------------------------------------------------------------------------------------------------
bool gt__2CUseAbilitiesUsed_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerExecute(gt__2CUseAbilitiesStartTimer, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt__2CUseAbilitiesUsed_Init () {
    gt__2CUseAbilitiesUsed = TriggerCreate("gt__2CUseAbilitiesUsed_Func");
    TriggerEnable(gt__2CUseAbilitiesUsed, false);
    TriggerAddEventUnitAbility(gt__2CUseAbilitiesUsed, UnitRefFromVariable("gv_hERO_Raynor"), AbilityCommand("RaynorPenetratingRound", 0), c_abilEffectStageCast, false);
    TriggerAddEventUnitAbility(gt__2CUseAbilitiesUsed, UnitRefFromVariable("gv_hERO_Raynor"), AbilityCommand("RaynorInspire", 0), c_abilEffectStageCast, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Objective Move To Beacon Create
//--------------------------------------------------------------------------------------------------
bool gt_ObjectiveMoveToBeaconCreate_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    ObjectiveCreateForPlayers(StringExternal("Param/Value/7151B2E3"), StringToText(""), c_objectiveStateActive, true, PlayerGroupSingle(gv_pLAYER_01_USER));
    gv_objectiveMoveToBeacon = ObjectiveLastCreated();
    Wait(2.0, c_timeReal);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_ObjectiveMoveToBeaconCreate_Init () {
    gt_ObjectiveMoveToBeaconCreate = TriggerCreate("gt_ObjectiveMoveToBeaconCreate_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Objective Move To Beacon Complete
//--------------------------------------------------------------------------------------------------
bool gt_ObjectiveMoveToBeaconComplete_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }

        if (!((gv_objectiveMoveToBeacon != c_invalidObjectiveId))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    ObjectiveSetState(gv_objectiveMoveToBeacon, c_objectiveStateCompleted);
    Wait(6.0, c_timeReal);
    ObjectiveDestroy(gv_objectiveMoveToBeacon);
    gv_objectiveMoveToBeacon = c_invalidObjectiveId;
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_ObjectiveMoveToBeaconComplete_Init () {
    gt_ObjectiveMoveToBeaconComplete = TriggerCreate("gt_ObjectiveMoveToBeaconComplete_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Objective Kill the Undead Create
//--------------------------------------------------------------------------------------------------
bool gt_ObjectiveKilltheUndeadCreate_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    ObjectiveCreateForPlayers(StringExternal("Param/Value/73312957"), StringToText(""), c_objectiveStateActive, true, PlayerGroupSingle(gv_pLAYER_01_USER));
    gv_objectiveKillTheUndead = ObjectiveLastCreated();
    Wait(2.0, c_timeReal);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_ObjectiveKilltheUndeadCreate_Init () {
    gt_ObjectiveKilltheUndeadCreate = TriggerCreate("gt_ObjectiveKilltheUndeadCreate_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Objective Kill the Undead Complete
//--------------------------------------------------------------------------------------------------
bool gt_ObjectiveKilltheUndeadComplete_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }

        if (!((gv_objectiveKillTheUndead != c_invalidObjectiveId))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    ObjectiveSetState(gv_objectiveKillTheUndead, c_objectiveStateCompleted);
    Wait(6.0, c_timeReal);
    ObjectiveDestroy(gv_objectiveKillTheUndead);
    gv_objectiveKillTheUndead = c_invalidObjectiveId;
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_ObjectiveKilltheUndeadComplete_Init () {
    gt_ObjectiveKilltheUndeadComplete = TriggerCreate("gt_ObjectiveKilltheUndeadComplete_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Objective Kill More Undead Create
//--------------------------------------------------------------------------------------------------
bool gt_ObjectiveKillMoreUndeadCreate_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TextExpressionSetToken("Param/Expression/F6487B70", "A", IntToText((gv__1B_AttackMoreSkeletonsCount - UnitGroupCount(gv__1B_AttackMoreSkeletonsAll, c_unitCountAlive))));
    TextExpressionSetToken("Param/Expression/F6487B70", "B", IntToText(gv__1B_AttackMoreSkeletonsCount));
    ObjectiveCreateForPlayers(TextExpressionAssemble("Param/Expression/F6487B70"), StringToText(""), c_objectiveStateActive, true, PlayerGroupSingle(gv_pLAYER_01_USER));
    gv_objectiveKillMoreUndead = ObjectiveLastCreated();
    Wait(2.0, c_timeReal);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_ObjectiveKillMoreUndeadCreate_Init () {
    gt_ObjectiveKillMoreUndeadCreate = TriggerCreate("gt_ObjectiveKillMoreUndeadCreate_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Objective Kill More Undead Update
//--------------------------------------------------------------------------------------------------
bool gt_ObjectiveKillMoreUndeadUpdate_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }

        if (!((gv_objectiveKillMoreUndead != c_invalidObjectiveId))) {
            return false;
        }
    }

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

    TextExpressionSetToken("Param/Expression/0486AEEE", "A", IntToText((gv__1B_AttackMoreSkeletonsCount - UnitGroupCount(gv__1B_AttackMoreSkeletonsAll, c_unitCountAlive))));
    TextExpressionSetToken("Param/Expression/0486AEEE", "B", IntToText(gv__1B_AttackMoreSkeletonsCount));
    ObjectiveSetName(gv_objectiveKillMoreUndead, TextExpressionAssemble("Param/Expression/0486AEEE"));
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_ObjectiveKillMoreUndeadUpdate_Init () {
    gt_ObjectiveKillMoreUndeadUpdate = TriggerCreate("gt_ObjectiveKillMoreUndeadUpdate_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Objective Kill More Undead Complete
//--------------------------------------------------------------------------------------------------
bool gt_ObjectiveKillMoreUndeadComplete_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }

        if (!((gv_objectiveKillMoreUndead != c_invalidObjectiveId))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    ObjectiveSetState(gv_objectiveKillMoreUndead, c_objectiveStateCompleted);
    Wait(6.0, c_timeReal);
    ObjectiveDestroy(gv_objectiveKillMoreUndead);
    gv_objectiveKillMoreUndead = c_invalidObjectiveId;
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_ObjectiveKillMoreUndeadComplete_Init () {
    gt_ObjectiveKillMoreUndeadComplete = TriggerCreate("gt_ObjectiveKillMoreUndeadComplete_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Objective Kill Zombies Create
//--------------------------------------------------------------------------------------------------
bool gt_ObjectiveKillZombiesCreate_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TextExpressionSetToken("Param/Expression/0CC0DBBD", "A", IntToText(gv__1C_ZombieCountKilled));
    TextExpressionSetToken("Param/Expression/0CC0DBBD", "B", IntToText(gv__1C_ZombieCountTotal));
    ObjectiveCreateForPlayers(TextExpressionAssemble("Param/Expression/0CC0DBBD"), StringToText(""), c_objectiveStateActive, true, PlayerGroupSingle(gv_pLAYER_01_USER));
    gv_objectiveKillZombies = ObjectiveLastCreated();
    libNtve_gf_CreatePingFacingAngle(PlayerGroupAll(), "PingObjective", UnitGroupCenterOfGroup(gv__1C_Zombies1), ColorWithAlpha(100.00, 0.00, 0.00, 0.00), 0.0, 270.0);
    gv__1C_SkeletonPings[1] = PingLastCreated();
    Wait(0.25, c_timeGame);
    libNtve_gf_CreatePingFacingAngle(PlayerGroupAll(), "PingObjective", UnitGroupCenterOfGroup(gv__1C_Zombies2), ColorWithAlpha(100.00, 0.00, 0.00, 0.00), 0.0, 270.0);
    gv__1C_SkeletonPings[2] = PingLastCreated();
    Wait(0.25, c_timeGame);
    libNtve_gf_CreatePingFacingAngle(PlayerGroupAll(), "PingObjective", UnitGroupCenterOfGroup(gv__1C_Zombies3), ColorWithAlpha(100.00, 0.00, 0.00, 0.00), 0.0, 270.0);
    gv__1C_SkeletonPings[3] = PingLastCreated();
    Wait(0.25, c_timeGame);
    libNtve_gf_CreatePingFacingAngle(PlayerGroupAll(), "PingObjective", UnitGroupCenterOfGroup(gv__1C_Zombies4), ColorWithAlpha(100.00, 0.00, 0.00, 0.00), 0.0, 270.0);
    gv__1C_SkeletonPings[4] = PingLastCreated();
    Wait(0.25, c_timeGame);
    libNtve_gf_CreatePingFacingAngle(PlayerGroupAll(), "PingObjective", UnitGroupCenterOfGroup(gv__1C_Zombies5), ColorWithAlpha(100.00, 0.00, 0.00, 0.00), 0.0, 270.0);
    gv__1C_SkeletonPings[5] = PingLastCreated();
    Wait(0.25, c_timeGame);
    libNtve_gf_CreatePingFacingAngle(PlayerGroupAll(), "PingObjective", UnitGroupCenterOfGroup(gv__1C_Zombies6), ColorWithAlpha(100.00, 0.00, 0.00, 0.00), 0.0, 270.0);
    gv__1C_SkeletonPings[6] = PingLastCreated();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_ObjectiveKillZombiesCreate_Init () {
    gt_ObjectiveKillZombiesCreate = TriggerCreate("gt_ObjectiveKillZombiesCreate_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Objective Kill Zombies Update
//--------------------------------------------------------------------------------------------------
bool gt_ObjectiveKillZombiesUpdate_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerExecute(gt_ObjectiveKillZombiesCreate, true, false);
    TextExpressionSetToken("Param/Expression/9B2A1FEA", "A", IntToText(gv__1C_ZombieCountKilled));
    TextExpressionSetToken("Param/Expression/9B2A1FEA", "B", IntToText(gv__1C_ZombieCountTotal));
    ObjectiveSetName(gv_objectiveKillZombies, TextExpressionAssemble("Param/Expression/9B2A1FEA"));
    if ((libNtve_gf_UnitGroupIsDead(gv__1C_Zombies1) == true) && (gv__1C_SkeletonPings[1] != c_invalidPingId)) {
        PingDestroy(gv__1C_SkeletonPings[1]);
        gv__1C_SkeletonPings[1] = c_invalidPingId;
    }
    else {
    }
    if ((libNtve_gf_UnitGroupIsDead(gv__1C_Zombies2) == true) && (gv__1C_SkeletonPings[2] != c_invalidPingId)) {
        PingDestroy(gv__1C_SkeletonPings[2]);
        gv__1C_SkeletonPings[2] = c_invalidPingId;
    }
    else {
    }
    if ((libNtve_gf_UnitGroupIsDead(gv__1C_Zombies3) == true) && (gv__1C_SkeletonPings[3] != c_invalidPingId)) {
        PingDestroy(gv__1C_SkeletonPings[3]);
        gv__1C_SkeletonPings[3] = c_invalidPingId;
    }
    else {
    }
    if ((libNtve_gf_UnitGroupIsDead(gv__1C_Zombies4) == true) && (gv__1C_SkeletonPings[4] != c_invalidPingId)) {
        PingDestroy(gv__1C_SkeletonPings[4]);
        gv__1C_SkeletonPings[4] = c_invalidPingId;
    }
    else {
    }
    if ((libNtve_gf_UnitGroupIsDead(gv__1C_Zombies5) == true) && (gv__1C_SkeletonPings[5] != c_invalidPingId)) {
        PingDestroy(gv__1C_SkeletonPings[5]);
        gv__1C_SkeletonPings[5] = c_invalidPingId;
    }
    else {
    }
    if ((libNtve_gf_UnitGroupIsDead(gv__1C_Zombies6) == true) && (gv__1C_SkeletonPings[6] != c_invalidPingId)) {
        PingDestroy(gv__1C_SkeletonPings[6]);
        gv__1C_SkeletonPings[6] = c_invalidPingId;
    }
    else {
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_ObjectiveKillZombiesUpdate_Init () {
    gt_ObjectiveKillZombiesUpdate = TriggerCreate("gt_ObjectiveKillZombiesUpdate_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Objective Kill Zombies Complete
//--------------------------------------------------------------------------------------------------
bool gt_ObjectiveKillZombiesComplete_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerExecute(gt_ObjectiveKillZombiesCreate, true, false);
    ObjectiveSetState(gv_objectiveKillZombies, c_objectiveStateCompleted);
    Wait(6.0, c_timeReal);
    ObjectiveDestroy(gv_objectiveKillZombies);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_ObjectiveKillZombiesComplete_Init () {
    gt_ObjectiveKillZombiesComplete = TriggerCreate("gt_ObjectiveKillZombiesComplete_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Objective Find Diablo Create
//--------------------------------------------------------------------------------------------------
bool gt_ObjectiveFindDiabloCreate_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    ObjectiveCreateForPlayers(StringExternal("Param/Value/3233CCD2"), StringToText(""), c_objectiveStateActive, true, PlayerGroupSingle(gv_pLAYER_01_USER));
    gv_objectiveFindDiablo = ObjectiveLastCreated();
    Wait(2.0, c_timeReal);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_ObjectiveFindDiabloCreate_Init () {
    gt_ObjectiveFindDiabloCreate = TriggerCreate("gt_ObjectiveFindDiabloCreate_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Objective Find Diablo Complete
//--------------------------------------------------------------------------------------------------
bool gt_ObjectiveFindDiabloComplete_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }

        if (!((gv_objectiveFindDiablo != c_invalidObjectiveId))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    ObjectiveSetState(gv_objectiveFindDiablo, c_objectiveStateCompleted);
    Wait(6.0, c_timeReal);
    ObjectiveDestroy(gv_objectiveFindDiablo);
    gv_objectiveFindDiablo = c_invalidObjectiveId;
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_ObjectiveFindDiabloComplete_Init () {
    gt_ObjectiveFindDiabloComplete = TriggerCreate("gt_ObjectiveFindDiabloComplete_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Objective Kill Diablo Create
//--------------------------------------------------------------------------------------------------
bool gt_ObjectiveKillDiabloCreate_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    ObjectiveCreateForPlayers(StringExternal("Param/Value/EDD2158A"), StringToText(""), c_objectiveStateActive, true, PlayerGroupSingle(gv_pLAYER_01_USER));
    gv_objectiveKillDiablo = ObjectiveLastCreated();
    Wait(2.0, c_timeReal);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_ObjectiveKillDiabloCreate_Init () {
    gt_ObjectiveKillDiabloCreate = TriggerCreate("gt_ObjectiveKillDiabloCreate_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Objective Kill Diablo Complete
//--------------------------------------------------------------------------------------------------
bool gt_ObjectiveKillDiabloComplete_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerExecute(gt_ObjectiveKillDiabloCreate, true, false);
    ObjectiveSetState(gv_objectiveKillDiablo, c_objectiveStateCompleted);
    Wait(6.0, c_timeReal);
    ObjectiveDestroy(gv_objectiveKillDiablo);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_ObjectiveKillDiabloComplete_Init () {
    gt_ObjectiveKillDiabloComplete = TriggerCreate("gt_ObjectiveKillDiabloComplete_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Objective Back to Base Create
//--------------------------------------------------------------------------------------------------
bool gt_ObjectiveBacktoBaseCreate_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    ObjectiveCreateForPlayers(StringExternal("Param/Value/A3A1FF3C"), StringToText(""), c_objectiveStateActive, true, libCore_gv_playerGroupFromPlayer[1]);
    gv_objectiveBacktoBase = ObjectiveLastCreated();
    Wait(2.0, c_timeReal);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_ObjectiveBacktoBaseCreate_Init () {
    gt_ObjectiveBacktoBaseCreate = TriggerCreate("gt_ObjectiveBacktoBaseCreate_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Objective Back to Base Complete
//--------------------------------------------------------------------------------------------------
bool gt_ObjectiveBacktoBaseComplete_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerExecute(gt_ObjectiveBacktoBaseCreate, true, false);
    ObjectiveSetState(gv_objectiveBacktoBase, c_objectiveStateCompleted);
    Wait(6.0, c_timeReal);
    ObjectiveDestroy(gv_objectiveBacktoBase);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_ObjectiveBacktoBaseComplete_Init () {
    gt_ObjectiveBacktoBaseComplete = TriggerCreate("gt_ObjectiveBacktoBaseComplete_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Objective Mount Up Create
//--------------------------------------------------------------------------------------------------
bool gt_ObjectiveMountUpCreate_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    ObjectiveCreateForPlayers(StringExternal("Param/Value/98B6D651"), StringToText(""), c_objectiveStateActive, true, libCore_gv_playerGroupFromPlayer[1]);
    gv_objectiveMountUp = ObjectiveLastCreated();
    Wait(2.0, c_timeReal);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_ObjectiveMountUpCreate_Init () {
    gt_ObjectiveMountUpCreate = TriggerCreate("gt_ObjectiveMountUpCreate_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Objective Mount Up Complete
//--------------------------------------------------------------------------------------------------
bool gt_ObjectiveMountUpComplete_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerExecute(gt_ObjectiveMountUpCreate, true, false);
    ObjectiveSetState(gv_objectiveMountUp, c_objectiveStateCompleted);
    Wait(6.0, c_timeReal);
    ObjectiveDestroy(gv_objectiveMountUp);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_ObjectiveMountUpComplete_Init () {
    gt_ObjectiveMountUpComplete = TriggerCreate("gt_ObjectiveMountUpComplete_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Objective Kill Enemy Towers Create
//--------------------------------------------------------------------------------------------------
bool gt_ObjectiveKillEnemyTowersCreate_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    ObjectiveCreateForPlayers(StringExternal("Param/Value/0E37CC6B"), StringToText(""), c_objectiveStateActive, true, PlayerGroupSingle(gv_pLAYER_01_USER));
    gv_objectiveKillEnemyTowers = ObjectiveLastCreated();
    Wait(2.0, c_timeReal);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_ObjectiveKillEnemyTowersCreate_Init () {
    gt_ObjectiveKillEnemyTowersCreate = TriggerCreate("gt_ObjectiveKillEnemyTowersCreate_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Objective Kill Enemy Towers Update
//--------------------------------------------------------------------------------------------------
bool gt_ObjectiveKillEnemyTowersUpdate_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_count;

    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerExecute(gt_ObjectiveKillEnemyTowersCreate, true, false);
    TextExpressionSetToken("Param/Expression/D3DDBDBC", "A", IntToText((2 - gv__2B_TowerAlives)));
    TextExpressionSetToken("Param/Expression/D3DDBDBC", "B", StringExternal("Param/Value/529A8A21"));
    ObjectiveSetName(gv_objectiveKillEnemyTowers, TextExpressionAssemble("Param/Expression/D3DDBDBC"));
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_ObjectiveKillEnemyTowersUpdate_Init () {
    gt_ObjectiveKillEnemyTowersUpdate = TriggerCreate("gt_ObjectiveKillEnemyTowersUpdate_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Objective Kill Enemy Towers Complete
//--------------------------------------------------------------------------------------------------
bool gt_ObjectiveKillEnemyTowersComplete_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerExecute(gt_ObjectiveKillEnemyTowersCreate, true, false);
    ObjectiveSetState(gv_objectiveKillEnemyTowers, c_objectiveStateCompleted);
    Wait(6.0, c_timeReal);
    ObjectiveDestroy(gv_objectiveKillEnemyTowers);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_ObjectiveKillEnemyTowersComplete_Init () {
    gt_ObjectiveKillEnemyTowersComplete = TriggerCreate("gt_ObjectiveKillEnemyTowersComplete_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Objective Kill Enemy Fort Create
//--------------------------------------------------------------------------------------------------
bool gt_ObjectiveKillEnemyFortCreate_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    ObjectiveCreateForPlayers(StringExternal("Param/Value/387B99B1"), StringToText(""), c_objectiveStateActive, true, PlayerGroupSingle(gv_pLAYER_01_USER));
    gv_objectiveKillEnemyFort = ObjectiveLastCreated();
    Wait(2.0, c_timeReal);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_ObjectiveKillEnemyFortCreate_Init () {
    gt_ObjectiveKillEnemyFortCreate = TriggerCreate("gt_ObjectiveKillEnemyFortCreate_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Objective Kill Enemy Fort Complete
//--------------------------------------------------------------------------------------------------
bool gt_ObjectiveKillEnemyFortComplete_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerExecute(gt_ObjectiveKillEnemyFortCreate, true, false);
    ObjectiveSetState(gv_objectiveKillEnemyFort, c_objectiveStateCompleted);
    Wait(6.0, c_timeReal);
    ObjectiveDestroy(gv_objectiveKillEnemyFort);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_ObjectiveKillEnemyFortComplete_Init () {
    gt_ObjectiveKillEnemyFortComplete = TriggerCreate("gt_ObjectiveKillEnemyFortComplete_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Objective Kill Enemy Palace Create
//--------------------------------------------------------------------------------------------------
bool gt_ObjectiveKillEnemyPalaceCreate_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    ObjectiveCreateForPlayers(StringExternal("Param/Value/F2DFC342"), StringToText(""), c_objectiveStateActive, true, PlayerGroupSingle(gv_pLAYER_01_USER));
    gv_objectiveKillEnemyPalace = ObjectiveLastCreated();
    Wait(2.0, c_timeReal);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_ObjectiveKillEnemyPalaceCreate_Init () {
    gt_ObjectiveKillEnemyPalaceCreate = TriggerCreate("gt_ObjectiveKillEnemyPalaceCreate_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Objective Kill Enemy Palace Complete
//--------------------------------------------------------------------------------------------------
bool gt_ObjectiveKillEnemyPalaceComplete_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerExecute(gt_ObjectiveKillEnemyPalaceCreate, true, false);
    ObjectiveSetState(gv_objectiveKillEnemyPalace, c_objectiveStateCompleted);
    Wait(6.0, c_timeReal);
    ObjectiveDestroy(gv_objectiveKillEnemyPalace);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_ObjectiveKillEnemyPalaceComplete_Init () {
    gt_ObjectiveKillEnemyPalaceComplete = TriggerCreate("gt_ObjectiveKillEnemyPalaceComplete_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Objective Move to Front Line Create
//--------------------------------------------------------------------------------------------------
bool gt_ObjectiveMovetoFrontLineCreate_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    ObjectiveCreateForPlayers(StringExternal("Param/Value/0A248930"), StringToText(""), c_objectiveStateActive, true, PlayerGroupSingle(gv_pLAYER_01_USER));
    gv_objectiveMovetoFrontLine = ObjectiveLastCreated();
    Wait(2.0, c_timeReal);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_ObjectiveMovetoFrontLineCreate_Init () {
    gt_ObjectiveMovetoFrontLineCreate = TriggerCreate("gt_ObjectiveMovetoFrontLineCreate_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Objective Move to Front Line Complete
//--------------------------------------------------------------------------------------------------
bool gt_ObjectiveMovetoFrontLineComplete_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerExecute(gt_ObjectiveMovetoFrontLineCreate, true, false);
    ObjectiveSetState(gv_objectiveMovetoFrontLine, c_objectiveStateCompleted);
    Wait(6.0, c_timeReal);
    ObjectiveDestroy(gv_objectiveMovetoFrontLine);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_ObjectiveMovetoFrontLineComplete_Init () {
    gt_ObjectiveMovetoFrontLineComplete = TriggerCreate("gt_ObjectiveMovetoFrontLineComplete_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Intro Q
//--------------------------------------------------------------------------------------------------
bool gt_IntroQ_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerQueueEnter();
    TriggerExecute(gt_IntroSetup, true, true);
    TriggerExecute(gt_IntroCinematic, true, true);
    TriggerExecute(gt_IntroCinematicEnd, true, true);
    TriggerExecute(gt_IntroCleanup, true, true);
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_IntroQ_Init () {
    gt_IntroQ = TriggerCreate("gt_IntroQ_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Intro Setup
//--------------------------------------------------------------------------------------------------
bool gt_IntroSetup_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    CinematicFade(false, 0.0, c_fadeStyleNormal, ColorWithAlpha(0.00, 0.00, 0.00, 0.00), 0.0, false);
    libStEx_gf_CinematicModeTutorial(true, PlayerGroupAll(), 0.0);
    libNtve_gf_GlobalCinematicSetting(true);
    libStEx_gf_TurnCinematicCameraOnOff(gv_pLAYER_01_USER, true);
    PlayerSetState(gv_pLAYER_01_USER, c_playerStateXPGain, false);
    GameTimeOfDayPause(true);
    libNtve_gf_ShowHideUnit(gv_hERO_Raynor, false);
    UnitSetPosition(gv_hERO_Raynor, PointFromId(7), false);
    UnitSetState(gv_hERO_Raynor, c_unitStateFidget, false);
    libNtve_gf_ShowHideUnit(gv_hERO_Instructor, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_IntroSetup_Init () {
    gt_IntroSetup = TriggerCreate("gt_IntroSetup_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Intro Cinematic
//--------------------------------------------------------------------------------------------------
bool gt_IntroCinematic_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    gv_cinematicCompleted = false;
    TriggerSkippableBegin(PlayerGroupAll(), 0, null, true, false);
    SoundtrackPause(PlayerGroupAll(), c_soundtrackCategoryMusic, true, false);
    DialogCreate(500, 400, c_anchorCenter, 0, 0, true);
    gv_intro_CutSceneDialog = DialogLastCreated();
    DialogSetFullscreen(DialogLastCreated(), true);
    DialogSetImageVisible(DialogLastCreated(), false);
    DialogControlCreate(DialogLastCreated(), c_triggerControlTypeCutscene);
    DialogControlSetFullDialog(DialogControlLastCreated(), PlayerGroupAll(), true);
    libNtve_gf_SetDialogItemCutscene(DialogControlLastCreated(), "Cutscenes\\Tutorial_Cutscene_RaynorIntro.StormCutscene", PlayerGroupAll());
    CutscenePlay(CutsceneGetTriggerControl(DialogControlLastCreated()));
    DialogSetVisible(DialogLastCreated(), PlayerGroupAll(), true);
    UISetWorldVisible(PlayerGroupAll(), false);
    CinematicFade(false, 0.0, c_fadeStyleNormal, Color(100.00, 100.00, 100.00), 0.0, true);
    WaitForCutsceneToEnd(CutsceneGetTriggerControl(DialogControlLastCreated()));
    UISetWorldVisible(PlayerGroupAll(), true);
    DialogDestroy(gv_intro_CutSceneDialog);
    gv_intro_CutSceneDialog = c_invalidDialogId;
    CutsceneCreateNoPosition("Cutscenes\\Tutorial_Cutscene_RaynorWarpIn.StormCutscene", PlayerGroupAll(), false);
    gv_intro_CutSceneWarpIn = CutsceneLastCreated();
    CutscenePlay(CutsceneLastCreated());
    CinematicFade(true, 1.0, c_fadeStyleNormal, Color(100.00, 100.00, 100.00), 0.0, false);
    WaitForCutsceneToEnd(CutsceneLastCreated());
    CinematicFade(false, 0.0, c_fadeStyleNormal, ColorWithAlpha(0.00, 0.00, 0.00, 0.00), 0.0, false);
    DialogCreate(500, 400, c_anchorCenter, 0, 0, true);
    gv_intro_CutSceneDialog = DialogLastCreated();
    DialogSetFullscreen(DialogLastCreated(), true);
    DialogSetImageVisible(DialogLastCreated(), false);
    DialogControlCreate(DialogLastCreated(), c_triggerControlTypeCutscene);
    DialogControlSetFullDialog(DialogControlLastCreated(), PlayerGroupAll(), true);
    libNtve_gf_SetDialogItemCutscene(DialogControlLastCreated(), "Cutscenes\\Tutorial_Cutscene_PlanetFlyby.StormCutscene", PlayerGroupAll());
    CutscenePlay(CutsceneGetTriggerControl(DialogControlLastCreated()));
    DialogSetVisible(DialogLastCreated(), PlayerGroupAll(), true);
    UISetWorldVisible(PlayerGroupAll(), false);
    Wait(2.0, c_timeGame);
    CinematicFade(true, 0.0, c_fadeStyleNormal, ColorWithAlpha(0.00, 0.00, 0.00, 0.00), 0.0, false);
    WaitForCutsceneToEnd(CutsceneGetTriggerControl(DialogControlLastCreated()));
    UISetWorldVisible(PlayerGroupAll(), true);
    DialogDestroy(gv_intro_CutSceneDialog);
    gv_intro_CutSceneDialog = c_invalidDialogId;
    CutsceneCreateNoPosition("Cutscenes\\Tutorial_Cutscene_NexusCameraPan.StormCutscene", PlayerGroupAll(), false);
    gv_intro_CutSceneStormGate = CutsceneLastCreated();
    CutscenePlay(CutsceneLastCreated());
    WaitForCutsceneToEnd(CutsceneLastCreated());
    gv_cinematicCompleted = true;
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_IntroCinematic_Init () {
    gt_IntroCinematic = TriggerCreate("gt_IntroCinematic_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Intro Cinematic End
//--------------------------------------------------------------------------------------------------
bool gt_IntroCinematicEnd_Func (bool testConds, bool runActions) {
    // Variable Declarations
    fixed lv_fadeDuration;

    // Variable Initialization

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

    if ((gv_cinematicCompleted == false)) {
        lv_fadeDuration = 0.5;
    }
    else {
        lv_fadeDuration = 0.0;
    }
    CinematicFade(false, lv_fadeDuration, c_fadeStyleNormal, ColorWithAlpha(0.00, 0.00, 0.00, 0.00), 0.0, true);
    SoundtrackStopCurrent(PlayerGroupAll(), c_soundtrackCategoryMusic, true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_IntroCinematicEnd_Init () {
    gt_IntroCinematicEnd = TriggerCreate("gt_IntroCinematicEnd_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Intro Cleanup
//--------------------------------------------------------------------------------------------------
bool gt_IntroCleanup_Func (bool testConds, bool runActions) {
    // Variable Declarations
    fixed lv_fadeDuration;

    // Variable Initialization

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

    UnitPauseAll(false);
    UnitGroupLoopBegin(gv_cinematicTempUnits);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        UnitRemove(UnitGroupLoopCurrent());
    }
    UnitGroupLoopEnd();
    UnitGroupLoopBegin(gv_cinematicHiddenUnits);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        libNtve_gf_ShowHideUnit(UnitGroupLoopCurrent(), true);
    }
    UnitGroupLoopEnd();
    if ((libNtve_gf_UnitIsHidden(gv_hERO_Raynor) == true)) {
        libNtve_gf_ShowHideUnit(gv_hERO_Raynor, true);
    }
    else {
    }
    if ((libNtve_gf_UnitIsHidden(gv_hERO_Instructor) == true)) {
        libNtve_gf_ShowHideUnit(gv_hERO_Instructor, true);
    }
    else {
    }
    GameTimeOfDayPause(false);
    ActorSend(gv_intro_TPEffect, "Destroy Immediate");
    VisExploreArea(gv_pLAYER_01_USER, RegionEntireMap(), false, false);
    gf_SetPlayableWithLooseCameraBounds(RegionFromId(4));
    VisRevealArea(gv_pLAYER_01_USER, RegionCircle(PointFromId(7), 10.0), 5.0, false);
    VisFillArea(gv_pLAYER_01_USER, RegionEntireMap(), c_fillTypeMasked, false);
    libNtve_gf_ShareVisionofUnit(gv_hERO_Instructor, true, gv_pLAYER_01_USER);
    CutsceneFade(true, 1.0, Color(0,0,0), 100.0, PlayerGroupAll(), true);
    UnitSetState(gv_hERO_Raynor, c_unitStateFidget, true);
    if ((gv_intro_CutSceneDialog != c_invalidDialogId)) {
        UISetWorldVisible(PlayerGroupAll(), true);
        DialogDestroy(gv_intro_CutSceneDialog);
        gv_intro_CutSceneDialog = c_invalidDialogId;
    }
    else {
    }
    if ((gv_intro_CutSceneWarpIn != c_cutsceneNone)) {
        CutsceneStop(gv_intro_CutSceneWarpIn);
    }
    else {
    }
    if ((gv_intro_CutSceneStormGate != c_cutsceneNone)) {
        CutsceneStop(gv_intro_CutSceneStormGate);
    }
    else {
    }
    TriggerExecute(gt__1ABeaconHighlight, true, false);
    CameraApplyInfo(gv_pLAYER_01_USER, CameraInfoDefault(), 0.0, -1, 10.0, false);
    CameraPan(gv_pLAYER_01_USER, UnitGetPosition(gv_hERO_Raynor), 0.0, -1, 10.0, false);
    libStEx_gf_TurnCinematicCameraOnOff(gv_pLAYER_01_USER, false);
    UnitSetPosition(gv_hERO_Raynor, PointFromId(34), false);
    UnitSetFacing(gv_hERO_Raynor, PointGetFacing(PointFromId(7)), 0.0);
    UnitSelect(gv_hERO_Raynor, gv_pLAYER_01_USER, true);
    libNtve_gf_PauseUnit(gv_hERO_Raynor, true);
    Wait(0.5, c_timeReal);
    lv_fadeDuration = 1.0;
    CinematicFade(true, lv_fadeDuration, c_fadeStyleNormal, ColorWithAlpha(0.00, 0.00, 0.00, 0.00), 0.0, false);
    libStEx_gf_CinematicModeTutorial(false, PlayerGroupAll(), 1.0);
    DialogControlSetVisible(libUIUI_gv_uIGameUIHandles.lv_minimapPanel, PlayerGroupAll(), false);
    libNtve_gf_GlobalCinematicSetting(false);
    libNtve_gf_SwooshCamera(gv_pLAYER_01_USER, ((CameraInfoGetValue(CameraInfoDefault(), c_cameraValueDistance)) + 8.0), CameraInfoGetValue(CameraInfoDefault(), c_cameraValueDistance), PointFromId(7), lv_fadeDuration);
    Wait(lv_fadeDuration, c_timeGame);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_IntroCleanup_Init () {
    gt_IntroCleanup = TriggerCreate("gt_IntroCleanup_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Intro Reticle Effect
//--------------------------------------------------------------------------------------------------
bool gt_IntroReticleEffect_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }

        if (!((EventCutsceneId() == gv_intro_CutSceneStormGate))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    UISetFrameVisible(PlayerGroupAll(), c_syncFrameTypeTextTag, true);
    TriggerExecute(gt__1ABeaconHighlight, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_IntroReticleEffect_Init () {
    gt_IntroReticleEffect = TriggerCreate("gt_IntroReticleEffect_Func");
    TriggerAddEventCutsceneBookmarkFired(gt_IntroReticleEffect, c_cutsceneNone, "Move");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MidSkeletonAttack Q
//--------------------------------------------------------------------------------------------------
bool gt_MidSkeletonAttackQ_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerQueueEnter();
    TriggerExecute(gt_MidSkeletonAttackSetup, true, true);
    TriggerExecute(gt_MidSkeletonAttackCinematic, true, true);
    TriggerExecute(gt_MidSkeletonAttackCinematicEnd, true, true);
    TriggerExecute(gt_MidSkeletonAttackCleanup, true, true);
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_MidSkeletonAttackQ_Init () {
    gt_MidSkeletonAttackQ = TriggerCreate("gt_MidSkeletonAttackQ_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MidSkeletonAttack Setup
//--------------------------------------------------------------------------------------------------
bool gt_MidSkeletonAttackSetup_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    libStEx_gf_ClearHintMessage();
    libStEx_gf_CinematicModeTutorial(true, PlayerGroupAll(), 1.0);
    Wait(1.0, c_timeReal);
    gf_SetPlayableWithLooseCameraBounds(RegionFromId(12));
    GameTimeOfDayPause(true);
    gv_cinematicHiddenUnits = UnitGroupEmpty();
    gv_cinematicTempUnits = UnitGroupEmpty();
    UnitIssueOrder(gv_hERO_Raynor, Order(AbilityCommand("move", 2)), c_orderQueueReplace);
    libNtve_gf_MakeUnitUncommandable(gv_hERO_Raynor, true);
    UnitSetState(gv_hERO_Raynor, c_unitStateFidget, false);
    gf_SetPlayableWithLooseCameraBounds(RegionEntireMap());
    gf_RestoreHero();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_MidSkeletonAttackSetup_Init () {
    gt_MidSkeletonAttackSetup = TriggerCreate("gt_MidSkeletonAttackSetup_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MidSkeletonAttack Cinematic
//--------------------------------------------------------------------------------------------------
bool gt_MidSkeletonAttackCinematic_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    SoundtrackPlay(PlayerGroupAll(), c_soundtrackCategoryMusic, "Storm_Music_Tutorial_Cutscene_Ghoul", c_soundtrackCueAny, c_soundtrackIndexAny, false);
    TriggerSkippableBegin(PlayerGroupAll(), 0, null, true, false);
    gv_cinematicCompleted = false;
    SoundPlayForPlayer(SoundLink("Gen_Hearthstone_Teleport_Start", -1), c_maxPlayers, PlayerGroupAll(), 100.0, 0.0);
    libNtve_gf_CreateModelAtPoint("TeleportChannelLaunchModel", UnitGetPosition(gv_hERO_Raynor));
    Wait(3.0, c_timeGame);
    libNtve_gf_ShowHideUnit(gv_hERO_Raynor, false);
    Wait(0.5, c_timeGame);
    libNtve_gf_KillModel(libNtve_gf_ActorLastCreated());
    SoundStop(SoundLastPlayed(), true);
    libStEx_gf_TurnCinematicCameraOnOff(gv_pLAYER_01_USER, true);
    SoundtrackPlay(PlayerGroupAll(), c_soundtrackCategoryAmbience, "Storm_Ambience_Tutorial_RavenCourt", c_soundtrackCueAny, c_soundtrackIndexAny, true);
    Wait(0.5, c_timeGame);
    TriggerExecute(gt_MidSkeletonAttackUtherMove, true, false);
    VisRevealerCreate(gv_pLAYER_01_USER, RegionFromId(56));
    gv_midSkeletonAttackRevealer = VisRevealerLastCreated();
    CameraApplyInfo(gv_pLAYER_01_USER, CameraInfoFromId(186), 0.0, -1, 10.0, true);
    gf_RestoreHero();
    UnitSetPosition(gv_hERO_Raynor, PointFromId(61), false);
    gf_CreateTeleportInModel(PointFromId(61));
    Wait(0.5, c_timeGame);
    libNtve_gf_ShowHideUnit(gv_hERO_Raynor, true);
    libStEx_gf_TurnCinematicCameraOnOff(gv_pLAYER_01_USER, false);
    Wait(1.0, c_timeGame);
    UnitIssueOrder(gv_hERO_Raynor, OrderTargetingPoint(AbilityCommand("move", 0), PointFromId(824)), c_orderQueueReplace);
    Wait(0.5, c_timeGame);
    libStEx_gf_TurnCinematicCameraOnOff(gv_pLAYER_01_USER, true);
    CameraPan(gv_pLAYER_01_USER, PointFromId(1231), 2.0, -1, 10.0, false);
    libNtve_gf_UnitCreateFacingPoint(1, "TutorialSkeletonAttack", 0, gv_pLAYER_12_CHAOS, PointFromId(30), PointFromId(46));
    SoundPlayForPlayer(SoundLink("Tutorial_Ghoul_Birth", -1), gv_pLAYER_01_USER, PlayerGroupAll(), 100.0, 0.0);
    UnitBehaviorRemovePlayer(UnitLastCreated(), "TutorialGhoulWander", 1, 1);
    gv__1B_AttackSkeleton1 = UnitLastCreated();
    libNtve_gf_PlayAnimation(libNtve_gf_MainActorofUnit(gv__1B_AttackSkeleton1), c_animNameDefault, "Birth", 0, 0.0);
    Wait(1.5, c_timeGame);
    UnitIssueOrder(gv__1B_AttackSkeleton1, OrderTargetingPoint(AbilityCommand("move", 0), PointFromId(46)), c_orderQueueReplace);
    UnitIssueOrder(gv__1B_AttackSkeleton1, Order(AbilityCommand("move", 2)), c_orderQueueAddToEnd);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(0, PlayerGroupAll());
    libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00473", c_transmissionDurationAdd, 0.0, true, 1, 0);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
    Wait(0.5, c_timeGame);
    CameraPan(gv_pLAYER_01_USER, UnitGetPosition(gv_hERO_Raynor), 2.0, -1, 10.0, false);
    Wait(2.0, c_timeGame);
    gv_cinematicCompleted = true;
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_MidSkeletonAttackCinematic_Init () {
    gt_MidSkeletonAttackCinematic = TriggerCreate("gt_MidSkeletonAttackCinematic_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MidSkeletonAttack Cinematic End
//--------------------------------------------------------------------------------------------------
bool gt_MidSkeletonAttackCinematicEnd_Func (bool testConds, bool runActions) {
    // Variable Declarations
    fixed lv_fadeDuration;

    // Variable Initialization

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

    TriggerStop(gt_MidSkeletonAttackUtherMove);
    if ((gv_cinematicCompleted == false)) {
        lv_fadeDuration = 0.5;
        CinematicFade(false, lv_fadeDuration, c_fadeStyleNormal, ColorWithAlpha(0.00, 0.00, 0.00, 0.00), 0.0, true);
    }
    else {
    }
    SoundtrackStopCurrent(PlayerGroupAll(), c_soundtrackCategoryMusic, true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_MidSkeletonAttackCinematicEnd_Init () {
    gt_MidSkeletonAttackCinematicEnd = TriggerCreate("gt_MidSkeletonAttackCinematicEnd_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MidSkeletonAttack Cleanup
//--------------------------------------------------------------------------------------------------
bool gt_MidSkeletonAttackCleanup_Func (bool testConds, bool runActions) {
    // Variable Declarations
    fixed lv_fadeDuration;

    // Variable Initialization

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

    libNtve_gf_PauseUnit(gv_hERO_Raynor, false);
    libNtve_gf_PauseUnit(gv_hERO_Instructor, true);
    RegionPlayableMapSet(RegionFromId(12));
    lv_fadeDuration = 1.0;
    if ((gv_midSkeletonAttackRevealer != null)) {
        VisRevealerDestroy(gv_midSkeletonAttackRevealer);
    }
    else {
    }
    UnitAbilityEnable(gv_hERO_Raynor, "move", false);
    if ((gv_cinematicCompleted == false)) {
        CameraApplyInfo(gv_pLAYER_01_USER, CameraInfoDefault(), 0.0, -1, 10.0, false);
        CameraPan(gv_pLAYER_01_USER, UnitGetPosition(gv_hERO_Raynor), 0.0, -1, 10.0, false);
        libStEx_gf_TurnCinematicCameraOnOff(gv_pLAYER_01_USER, false);
        libNtve_gf_ClearAnimation(libNtve_gf_MainActorofUnit(gv_hERO_Diablo), c_animNameDefault);
        UnitSetPosition(gv_hERO_Raynor, PointFromId(824), false);
        libNtve_gf_MakeUnitUncommandable(gv_hERO_Raynor, false);
        UnitSetPosition(gv_hERO_Instructor, PointFromId(28), false);
        if ((libNtve_gf_UnitIsVisibleToPlayer(gv_hERO_Raynor, gv_pLAYER_01_USER) == false)) {
            libNtve_gf_ShowHideUnit(gv_hERO_Raynor, true);
        }
        else {
        }
        if ((libNtve_gf_UnitIsVisibleToPlayer(gv_hERO_Instructor, gv_pLAYER_01_USER) == false)) {
            libNtve_gf_ShowHideUnit(gv_hERO_Instructor, true);
        }
        else {
        }
        if ((gv__1B_AttackSkeleton1 == null)) {
            libNtve_gf_CreateUnitsAtPoint2(1, "TutorialSkeletonAttack", c_unitCreateIgnorePlacement, gv_pLAYER_12_CHAOS, PointFromId(46));
            UnitBehaviorRemovePlayer(UnitLastCreated(), "TutorialGhoulWander", 1, 1);
            gv__1B_AttackSkeleton1 = UnitLastCreated();
        }
        else {
        }
        UnitSelect(gv_hERO_Raynor, gv_pLAYER_01_USER, true);
        gf_RestoreHero();
        VisRevealArea(gv_pLAYER_01_USER, RegionFromId(23), 2.0, false);
        Wait(0.5, c_timeReal);
        SoundtrackPlay(PlayerGroupAll(), c_soundtrackCategoryAmbience, "Storm_Ambience_Tutorial_RavenCourt", c_soundtrackCueAny, c_soundtrackIndexAny, true);
        libStEx_gf_CinematicModeTutorial(false, PlayerGroupAll(), lv_fadeDuration);
        DialogControlSetVisible(libUIUI_gv_uIGameUIHandles.lv_minimapPanel, PlayerGroupAll(), false);
        CinematicFade(true, lv_fadeDuration, c_fadeStyleNormal, ColorWithAlpha(0.00, 0.00, 0.00, 0.00), 0.0, false);
    }
    else {
        libStEx_gf_CinematicModeTutorial(false, PlayerGroupAll(), lv_fadeDuration);
        DialogControlSetVisible(libUIUI_gv_uIGameUIHandles.lv_minimapPanel, PlayerGroupAll(), false);
        UnitSetState(gv_hERO_Raynor, c_unitStateFidget, true);
        UnitSelect(gv_hERO_Raynor, gv_pLAYER_01_USER, true);
        libNtve_gf_MakeUnitUncommandable(gv_hERO_Raynor, false);
        CameraApplyInfo(gv_pLAYER_01_USER, CameraInfoDefault(), 1.0, -1, 10.0, true);
        libStEx_gf_TurnCinematicCameraOnOff(gv_pLAYER_01_USER, false);
        gf_RestoreHero();
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_MidSkeletonAttackCleanup_Init () {
    gt_MidSkeletonAttackCleanup = TriggerCreate("gt_MidSkeletonAttackCleanup_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MidSkeletonAttack Uther Move
//--------------------------------------------------------------------------------------------------
bool gt_MidSkeletonAttackUtherMove_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    Wait(1.0, c_timeGame);
    gf_CreateTeleportInModel(PointFromId(182));
    if ((libNtve_gf_UnitIsVisibleToPlayer(gv_hERO_Instructor, gv_pLAYER_01_USER) == true)) {
        libNtve_gf_ShowHideUnit(gv_hERO_Instructor, false);
    }
    else {
    }
    UnitSetPosition(gv_hERO_Instructor, PointFromId(182), false);
    UnitSetFacing(gv_hERO_Instructor, PointGetFacing(PointFromId(182)), 0.0);
    Wait(0.5, c_timeGame);
    libNtve_gf_ShowHideUnit(gv_hERO_Instructor, true);
    Wait(0.5, c_timeGame);
    libNtve_gf_PauseUnit(gv_hERO_Instructor, false);
    UnitIssueOrder(gv_hERO_Instructor, OrderTargetingPoint(AbilityCommand("move", 0), PointFromId(28)), c_orderQueueReplace);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_MidSkeletonAttackUtherMove_Init () {
    gt_MidSkeletonAttackUtherMove = TriggerCreate("gt_MidSkeletonAttackUtherMove_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MidAbility Q
//--------------------------------------------------------------------------------------------------
bool gt_MidAbilityQ_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerQueueEnter();
    TriggerExecute(gt_MidAbilitySetup, true, true);
    TriggerExecute(gt_MidAbilityCinematic, true, true);
    TriggerExecute(gt_MidAbilityCinematicEnd, true, true);
    TriggerExecute(gt_MidAbilityCleanup, true, true);
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_MidAbilityQ_Init () {
    gt_MidAbilityQ = TriggerCreate("gt_MidAbilityQ_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MidAbility Setup
//--------------------------------------------------------------------------------------------------
bool gt_MidAbilitySetup_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    libStEx_gf_ClearHintMessage();
    CinematicFade(false, 1.0, c_fadeStyleNormal, ColorWithAlpha(0.00, 0.00, 0.00, 0.00), 0.0, false);
    UISetMode(PlayerGroupAll(), c_uiModeFullscreen, 1.0);
    Wait(1.0, c_timeReal);
    libStEx_gf_CinematicModeTutorial(true, PlayerGroupAll(), 0.0);
    libNtve_gf_GlobalCinematicSetting(true);
    GameTimeOfDayPause(true);
    UnitGroupLoopBegin(UnitGroup(null, c_playerAny, null, UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32))), 0));
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        if ((libNtve_gf_UnitIsPaused(UnitGroupLoopCurrent()) == false) && (UnitGroupLoopCurrent() != gv_hERO_Raynor) && (UnitGroupLoopCurrent() != gv_hERO_Instructor)) {
            UnitGroupAdd(gv_cinematicPausedUnits, UnitGroupLoopCurrent());
            libNtve_gf_PauseUnit(UnitGroupLoopCurrent(), true);
        }
        else {
        }
    }
    UnitGroupLoopEnd();
    gv_cinematicHiddenUnits = UnitGroupEmpty();
    gv_cinematicTempUnits = UnitGroupEmpty();
    UnitGroupLoopBegin(gv_cinematicHiddenUnits);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        libNtve_gf_ShowHideUnit(UnitGroupLoopCurrent(), false);
    }
    UnitGroupLoopEnd();
    gf_SetPlayableWithLooseCameraBounds(RegionEntireMap());
    UnitSetPosition(gv_hERO_Raynor, PointFromId(1522), false);
    libNtve_gf_MakeUnitFacePoint(gv_hERO_Raynor, PointFromId(1203), 0.0);
    libNtve_gf_MakeUnitInvulnerable(gv_hERO_Raynor, true);
    libNtve_gf_PauseUnit(gv_hERO_Raynor, false);
    UnitIssueOrder(gv_hERO_Raynor, OrderTargetingPoint(AbilityCommand("move", 0), PointFromId(1203)), c_orderQueueReplace);
    UnitSetState(gv_hERO_Raynor, c_unitStateFidget, false);
    UnitSetPosition(gv_hERO_Instructor, PointFromId(1242), false);
    libNtve_gf_MakeUnitFacePoint(gv_hERO_Instructor, PointFromId(1244), 0.0);
    libNtve_gf_MakeUnitInvulnerable(gv_hERO_Instructor, true);
    libNtve_gf_PauseUnit(gv_hERO_Instructor, false);
    UnitIssueOrder(gv_hERO_Instructor, OrderTargetingPoint(AbilityCommand("move", 0), PointFromId(1244)), c_orderQueueReplace);
    libNtve_gf_MakeUnitInvulnerable(gv_hERO_Diablo, true);
    UnitGroupLoopBegin(gv__1B_AttackMoreSkeletonsC);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        libNtve_gf_ShowHideUnit(UnitGroupLoopCurrent(), false);
    }
    UnitGroupLoopEnd();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_MidAbilitySetup_Init () {
    gt_MidAbilitySetup = TriggerCreate("gt_MidAbilitySetup_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MidAbility Cinematic
//--------------------------------------------------------------------------------------------------
bool gt_MidAbilityCinematic_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    SoundtrackPlay(PlayerGroupAll(), c_soundtrackCategoryMusic, "Storm_Music_Tutorial_Cutscene_Ghoul", c_soundtrackCueAny, c_soundtrackIndexAny, false);
    gv_cinematicCompleted = false;
    libStEx_gf_TurnCinematicCameraOnOff(gv_pLAYER_01_USER, true);
    CameraApplyInfo(gv_pLAYER_01_USER, CameraInfoFromId(2450), 0.0, -1, 10.0, true);
    CameraApplyInfo(gv_pLAYER_01_USER, CameraInfoFromId(262), (SoundLengthSync(SoundLink(ConversationDataGetSound("TutorialVO|Line00479", true), c_soundIndexAny))+0.0+1), -1, 10.0, true);
    CinematicFade(true, 1.0, c_fadeStyleNormal, ColorWithAlpha(0.00, 0.00, 0.00, 0.00), 0.0, true);
    TriggerSkippableBegin(PlayerGroupAll(), 0, null, true, false);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(0, PlayerGroupAll());
    libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00479", c_transmissionDurationAdd, 0.0, true, 1, 0);
    libCore_gf_SendTransmissionCampaign(gv_hERO_Raynor, "TutorialVO|Line00532", c_transmissionDurationAdd, 0.0, true, 1, 0);
    CameraApplyInfo(gv_pLAYER_01_USER, CameraInfoFromId(2451), SoundLengthSync(SoundLink(ConversationDataGetSound("TutorialVO|Line00533", true), c_soundIndexAny)), -1, 10.0, true);
    libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00533", c_transmissionDurationAdd, 0.0, true, 1, 0);
    CameraApplyInfo(gv_pLAYER_01_USER, CameraInfoFromId(1252), 0.0, -1, 10.0, true);
    libCore_gf_SendTransmissionCampaign(gv_hERO_Raynor, "TutorialVO|Line00348", c_transmissionDurationAdd, 0.0, true, 1, 0);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
    SoundtrackPlay(PlayerGroupAll(), c_soundtrackCategoryAmbience, "KingsCrestAmbientNight", c_soundtrackCueAny, c_soundtrackIndexAny, true);
    CameraApplyInfo(gv_pLAYER_01_USER, CameraInfoFromId(1237), (SoundLengthSync(SoundLink(ConversationDataGetSound("TutorialVO|Line00232", false), c_soundIndexAny)) + 4.0), -1, 10.0, true);
    libNtve_gf_CreateModelAtPoint("DiabloApocalypseExplode", PointFromId(1239));
    Wait(0.5, c_timeGame);
    SoundPlayForPlayer(SoundLink("UI_Game_LevelUp", -1), c_maxPlayers, PlayerGroupAll(), 100.0, 0.0);
    Wait(1.0, c_timeGame);
    SoundPlayForPlayer(SoundLink("Diablo_ShadowFlame_Launch", -1), c_maxPlayers, PlayerGroupAll(), 100.0, 0.0);
    Wait(0.5, c_timeGame);
    UnitSetPosition(gv_hERO_Diablo, PointFromId(1239), false);
    UnitSetFacing(gv_hERO_Diablo, PointGetFacing(PointFromId(1239)), 0.0);
    Wait(1.0, c_timeGame);
    libNtve_gf_KillModel(libNtve_gf_ActorLastCreated());
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(0, PlayerGroupAll());
    libCore_gf_SendTransmissionCampaign(gv_hERO_Diablo, "TutorialVO|Line00232", c_transmissionDurationAdd, 0.0, true, 1, 0);
    libNtve_gf_PlayAnimation(libNtve_gf_MainActorofUnit(gv_hERO_Diablo), c_animNameDefault, "Spell C", c_animFlagNonLooping, c_animTimeDefault);
    Wait(2.0, c_timeGame);
    libCore_gf_SendTransmissionCampaign(gv_hERO_Diablo, "TutorialVO|Line00349", c_transmissionDurationAdd, 0.0, true, 1, 0);
    UnitSetPosition(gv_hERO_Raynor, PointFromId(1235), false);
    UnitSetFacing(gv_hERO_Raynor, PointGetFacing(PointFromId(1235)), 0.0);
    libNtve_gf_ShowHideUnit(gv_hERO_Raynor, true);
    UnitGroupRemove(gv_cinematicHiddenUnits, gv_hERO_Raynor);
    UnitSetPosition(gv_hERO_Instructor, PointFromId(1254), false);
    UnitSetFacing(gv_hERO_Instructor, PointGetFacing(PointFromId(1254)), 0.0);
    libNtve_gf_ShowHideUnit(gv_hERO_Instructor, true);
    UnitGroupRemove(gv_cinematicHiddenUnits, gv_hERO_Instructor);
    CameraApplyInfo(gv_pLAYER_01_USER, CameraInfoFromId(1240), 0.0, -1, 10.0, true);
    libCore_gf_SendTransmissionCampaign(gv_hERO_Raynor, "TutorialVO|Line00350", c_transmissionDurationAdd, 0.0, true, 1, 0);
    CameraApplyInfo(gv_pLAYER_01_USER, CameraInfoFromId(1238), 0.0, -1, 10.0, true);
    libNtve_gf_PlayAnimation(libNtve_gf_MainActorofUnit(gv_hERO_Diablo), c_animNameDefault, "Spell A", c_animFlagNonLooping, c_animTimeDefault);
    Wait(0.8, c_timeGame);
    libCore_gf_SendTransmissionCampaign(gv_hERO_Diablo, "TutorialVO|Line00351", c_transmissionDurationAdd, 0.0, true, 1, 0);
    SoundPlayForPlayer(SoundLink("Gen_Hearthstone_Teleport_Start", -1), c_maxPlayers, PlayerGroupAll(), 100.0, 0.0);
    libNtve_gf_PlayAnimation(libNtve_gf_MainActorofUnit(gv_hERO_Diablo), c_animNameDefault, "Spell Channel", c_animFlagPlayForever, c_animTimeDefault);
    libNtve_gf_CreateModelAtPoint("TeleportChannelLaunchModel", UnitGetPosition(gv_hERO_Diablo));
    Wait(3.0, c_timeGame);
    UnitSetPosition(gv_hERO_Diablo, libCore_gf_PointStoredForUnit(gv_hERO_Diablo, 1), false);
    libNtve_gf_ClearAnimation(libNtve_gf_MainActorofUnit(gv_hERO_Diablo), c_animNameDefault);
    Wait(0.5, c_timeGame);
    libNtve_gf_KillModel(libNtve_gf_ActorLastCreated());
    Wait(1.0, c_timeGame);
    libStEx_gf_MoveUnit(gv_hERO_Raynor, PointFromId(158), false);
    CameraApplyInfo(gv_pLAYER_01_USER, CameraInfoFromId(268), 0.0, -1, 10.0, true);
    UnitIssueOrder(gv_hERO_Raynor, Order(AbilityCommand("move", 2)), c_orderQueueReplace);
    libCore_gf_SendTransmissionCampaign(gv_hERO_Raynor, "TutorialVO|Line00352", c_transmissionDurationAdd, 0.0, true, 2, 0);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
    Wait(1.0, c_timeGame);
    gv_cinematicCompleted = true;
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_MidAbilityCinematic_Init () {
    gt_MidAbilityCinematic = TriggerCreate("gt_MidAbilityCinematic_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MidAbility Cinematic End
//--------------------------------------------------------------------------------------------------
bool gt_MidAbilityCinematicEnd_Func (bool testConds, bool runActions) {
    // Variable Declarations
    fixed lv_fadeDuration;

    // Variable Initialization

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

    if ((gv_cinematicCompleted == false)) {
        lv_fadeDuration = 0.5;
        CinematicFade(false, lv_fadeDuration, c_fadeStyleNormal, ColorWithAlpha(0.00, 0.00, 0.00, 0.00), 0.0, true);
        SoundtrackStopCurrent(PlayerGroupAll(), c_soundtrackCategoryMusic, true);
    }
    else {
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_MidAbilityCinematicEnd_Init () {
    gt_MidAbilityCinematicEnd = TriggerCreate("gt_MidAbilityCinematicEnd_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MidAbility Cleanup
//--------------------------------------------------------------------------------------------------
bool gt_MidAbilityCleanup_Func (bool testConds, bool runActions) {
    // Variable Declarations
    fixed lv_fadeDuration;

    // Variable Initialization

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

    UnitGroupLoopBegin(gv_cinematicTempUnits);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        UnitRemove(UnitGroupLoopCurrent());
    }
    UnitGroupLoopEnd();
    UnitGroupLoopBegin(gv_cinematicHiddenUnits);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        libNtve_gf_ShowHideUnit(UnitGroupLoopCurrent(), true);
    }
    UnitGroupLoopEnd();
    UnitGroupLoopBegin(gv_cinematicPausedUnits);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        libNtve_gf_PauseUnit(UnitGroupLoopCurrent(), false);
    }
    UnitGroupLoopEnd();
    GameTimeOfDayPause(false);
    libNtve_gf_RestoreUnitSelection(gv_pLAYER_01_USER);
    VisExploreArea(gv_pLAYER_01_USER, RegionEntireMap(), false, false);
    UnitGroupLoopBegin(gv__1C_Zombies);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        if ((UnitGroupHasUnit(gv__1C_Zombies1, UnitGroupLoopCurrent()) == false) && (UnitGroupHasUnit(gv__1C_Zombies2, UnitGroupLoopCurrent()) == false) && (UnitGroupHasUnit(gv__1C_Zombies3, UnitGroupLoopCurrent()) == false)) {
            libNtve_gf_ShowHideUnit(UnitGroupLoopCurrent(), true);
            libNtve_gf_PauseUnit(UnitGroupLoopCurrent(), false);
        }
        else {
        }
    }
    UnitGroupLoopEnd();
    libNtve_gf_MakeUnitInvulnerable(gv_hERO_Raynor, false);
    gf_SetPlayableWithLooseCameraBounds(RegionFromId(17));
    UnitSetPosition(gv_hERO_Diablo, libCore_gf_PointStoredForUnit(gv_hERO_Diablo, 1), false);
    UnitSetFacing(gv_hERO_Diablo, PointGetFacing(libCore_gf_PointStoredForUnit(gv_hERO_Diablo, 1)), 0.0);
    UnitSetState(gv_hERO_Raynor, c_unitStateFidget, true);
    UnitSetPosition(gv_hERO_Instructor, PointFromId(1253), false);
    UnitSetFacing(gv_hERO_Instructor, PointGetFacing(PointFromId(1253)), 0.0);
    lv_fadeDuration = 1.0;
    if ((gv_cinematicCompleted == false)) {
        UISetWorldVisible(PlayerGroupAll(), true);
        CameraApplyInfo(gv_pLAYER_01_USER, CameraInfoDefault(), 0.0, -1, 10.0, false);
        CameraPan(gv_pLAYER_01_USER, UnitGetPosition(gv_hERO_Raynor), 0.0, -1, 10.0, false);
        libStEx_gf_TurnCinematicCameraOnOff(gv_pLAYER_01_USER, false);
        libNtve_gf_ClearAnimation(libNtve_gf_MainActorofUnit(gv_hERO_Diablo), c_animNameDefault);
        UnitSetPosition(gv_hERO_Raynor, PointFromId(158), false);
        libNtve_gf_MakeUnitUncommandable(gv_hERO_Raynor, true);
        if ((libNtve_gf_UnitIsVisibleToPlayer(gv_hERO_Raynor, gv_pLAYER_01_USER) == false)) {
            libNtve_gf_ShowHideUnit(gv_hERO_Raynor, true);
        }
        else {
        }
        UnitSelect(gv_hERO_Raynor, gv_pLAYER_01_USER, true);
        gf_RestoreHero();
        VisRevealArea(gv_pLAYER_01_USER, RegionFromId(23), 2.0, false);
        Wait(0.5, c_timeReal);
        SoundtrackPlay(PlayerGroupAll(), c_soundtrackCategoryAmbience, "Storm_Ambience_Tutorial_RavenCourt", c_soundtrackCueAny, c_soundtrackIndexAny, true);
        CinematicFade(true, lv_fadeDuration, c_fadeStyleNormal, ColorWithAlpha(0.00, 0.00, 0.00, 0.00), 0.0, false);
    }
    else {
        UnitSelect(gv_hERO_Raynor, gv_pLAYER_01_USER, true);
        CameraApplyInfo(gv_pLAYER_01_USER, CameraInfoDefault(), 1.5, -1, 10.0, true);
        libStEx_gf_TurnCinematicCameraOnOff(gv_pLAYER_01_USER, false);
        libNtve_gf_MakeUnitUncommandable(gv_hERO_Raynor, true);
        gf_RestoreHero();
        VisRevealArea(gv_pLAYER_01_USER, RegionFromId(23), 2.0, false);
    }
    TriggerExecute(gt__1CPenRoundPrep, true, false);
    libStEx_gf_CinematicModeTutorial(false, PlayerGroupAll(), lv_fadeDuration);
    libNtve_gf_GlobalCinematicSetting(false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_MidAbilityCleanup_Init () {
    gt_MidAbilityCleanup = TriggerCreate("gt_MidAbilityCleanup_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MidGarrison Q
//--------------------------------------------------------------------------------------------------
bool gt_MidGarrisonQ_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerQueueEnter();
    TriggerExecute(gt_MidGarrisonSetup, true, true);
    TriggerExecute(gt_MidGarrisonCinematic, true, true);
    TriggerExecute(gt_MidGarrisonCinematicEnd, true, true);
    TriggerExecute(gt_MidGarrisonCleanup, true, true);
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_MidGarrisonQ_Init () {
    gt_MidGarrisonQ = TriggerCreate("gt_MidGarrisonQ_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MidGarrison Setup
//--------------------------------------------------------------------------------------------------
bool gt_MidGarrisonSetup_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    libStEx_gf_ClearHintMessage();
    CinematicFade(false, 1.0, c_fadeStyleNormal, ColorWithAlpha(0.00, 0.00, 0.00, 0.00), 0.0, false);
    UISetMode(PlayerGroupAll(), c_uiModeFullscreen, 1.0);
    Wait(1.0, c_timeReal);
    libStEx_gf_CinematicModeTutorial(true, PlayerGroupAll(), 0.0);
    libNtve_gf_GlobalCinematicSetting(true);
    libStEx_gf_TurnCinematicCameraOnOff(gv_pLAYER_01_USER, true);
    libNtve_gf_ClearAnimation(libNtve_gf_MainActorofUnit(libGame_gv_teams[libGame_gv_teamOrderIndex_C].lv_core), "CoreStart");
    libNtve_gf_ClearAnimation(libNtve_gf_MainActorofUnit(libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_core), "CoreStart");
    GameTimeOfDayPause(true);
    UnitGroupLoopBegin(UnitGroup(null, c_playerAny, null, UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32))), 0));
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        if ((libNtve_gf_UnitIsPaused(UnitGroupLoopCurrent()) == false) && (UnitGroupLoopCurrent() != gv_hERO_Raynor)) {
            UnitGroupAdd(gv_cinematicPausedUnits, UnitGroupLoopCurrent());
            libNtve_gf_PauseUnit(UnitGroupLoopCurrent(), true);
        }
        else {
        }
    }
    UnitGroupLoopEnd();
    libNtve_gf_PauseUnit(UnitFromId(37), false);
    libNtve_gf_PauseUnit(UnitFromId(39), false);
    gv_cinematicHiddenUnits = UnitGroupEmpty();
    gv_cinematicTempUnits = UnitGroupEmpty();
    UnitGroupLoopBegin(gv_cinematicHiddenUnits);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        libNtve_gf_ShowHideUnit(UnitGroupLoopCurrent(), false);
    }
    UnitGroupLoopEnd();
    gf_SetPlayableWithLooseCameraBounds(RegionFromId(34));
    libNtve_gf_SetAlliance(gv_pLAYER_01_USER, gv_pLAYER_02_UTHER, 2);
    libNtve_gf_SetAlliance(gv_pLAYER_01_USER, gv_pLAYER_11_ORDER, 2);
    libNtve_gf_SetAlliance(gv_pLAYER_02_UTHER, gv_pLAYER_11_ORDER, 2);
    libNtve_gf_SetAlliance(gv_pLAYER_06_DIABLO, gv_pLAYER_07_STITCHES, 2);
    libNtve_gf_SetAlliance(gv_pLAYER_06_DIABLO, gv_pLAYER_12_CHAOS, 2);
    libNtve_gf_SetAlliance(gv_pLAYER_07_STITCHES, gv_pLAYER_12_CHAOS, 2);
    UnitSetPosition(gv_hERO_Raynor, PointFromId(1930), false);
    UnitSetFacing(gv_hERO_Raynor, PointGetFacing(PointFromId(1930)), 0.0);
    libNtve_gf_MakeUnitUncommandable(gv_hERO_Raynor, true);
    UnitSetState(gv_hERO_Raynor, c_unitStateFidget, false);
    gf_RestoreHero();
    UnitSetPosition(gv_hERO_Instructor, PointFromId(2170), false);
    UnitSetFacing(gv_hERO_Instructor, PointGetFacing(PointFromId(2170)), 0.0);
    libNtve_gf_MakeUnitInvulnerable(gv_hERO_Instructor, true);
    libNtve_gf_ShowHideUnit(gv_hERO_Instructor, true);
    UnitSetOwner(gv_hERO_Instructor, gv_pLAYER_02_UTHER, true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_MidGarrisonSetup_Init () {
    gt_MidGarrisonSetup = TriggerCreate("gt_MidGarrisonSetup_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MidGarrison Cinematic
//--------------------------------------------------------------------------------------------------
bool gt_MidGarrisonCinematic_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    SoundtrackPlay(PlayerGroupAll(), c_soundtrackCategoryMusic, "Storm_Music_Tutorial_Cutscene_Core", c_soundtrackCueAny, c_soundtrackIndexAny, false);
    CameraApplyInfo(gv_pLAYER_01_USER, CameraInfoFromId(2084), 0.0, -1, 10, true);
    CameraApplyInfo(gv_pLAYER_01_USER, CameraInfoFromId(2085), 30.0, -1, 10, true);
    TriggerSkippableBegin(PlayerGroupAll(), 0, null, true, false);
    gv_cinematicCompleted = false;
    CinematicFade(true, 1.0, c_fadeStyleNormal, ColorWithAlpha(0.00, 0.00, 0.00, 0.00), 0.0, true);
    libNtve_gf_ShowHideUnit(gv_hERO_Raynor, true);
    libNtve_gf_AttachModelToUnit(gv_hERO_Raynor, "TeleportChargeFinal", "Ref_Origin");
    gv_midGarrision_RaynorTeleportEffect = libNtve_gf_ActorLastCreated();
    SoundPlayForPlayer(SoundLink("Gen_Hearthstone_Teleport_Done", -1), c_maxPlayers, PlayerGroupAll(), 100.0, 0.0);
    Wait(1.0, c_timeGame);
    libNtve_gf_KillModel(gv_midGarrision_RaynorTeleportEffect);
    Wait(1.0, c_timeGame);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(0, PlayerGroupAll());
    libCore_gf_SendTransmissionCampaign(gv_hERO_Raynor, "TutorialVO|Line00300", c_transmissionDurationAdd, 0.0, true, 1, 0);
    libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00260", c_transmissionDurationAdd, 0.0, true, 1, 0);
    CameraApplyInfo(gv_pLAYER_01_USER, CameraInfoFromId(2086), 0.0, -1, 10.0, true);
    CameraApplyInfo(gv_pLAYER_01_USER, CameraInfoFromId(2087), 5.0, -1, 10, true);
    libNtve_gf_TurnAnimationPropertiesOff(libNtve_gf_MainActorofUnit(libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_core), "Work");
    libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00261", c_transmissionDurationAdd, 0.0, false, 1, 0);
    TransmissionWait(TransmissionLastSent(), 3.0);
    libCore_gf_AttachReticleEffectAndTextTagOnUnit(2, 0, null, libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_core, "Ref_Center");
    libCore_gf_StoreActorForUnit(libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_core, 1, libNtve_gf_ActorLastCreated());
    TransmissionWait(TransmissionLastSent(), 0.0);
    TriggerExecute(gt_MidGarrisonCinematicMinionCamera, true, false);
    Wait(0.5, c_timeGame);
    TriggerExecute(gt_MidGarrisonCinematicSpawnChaosWave, true, false);
    Wait(1.0, c_timeGame);
    libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00262", c_transmissionDurationAdd, 0.0, false, 1, 0);
    TriggerExecute(gt_MidGarrisonCinematicSpawnOrderWave, true, false);
    TransmissionWait(TransmissionLastSent(), 2.0);
    UnitGroupIssueOrder(gv_midGarrision_OrdersWave, OrderTargetingPoint(AbilityCommand("attack", 0), PointFromId(2172)), c_orderQueueReplace);
    TransmissionWait(TransmissionLastSent(), 0.0);
    libCore_gf_SendTransmissionCampaign(gv_hERO_Raynor, "TutorialVO|Line00273", c_transmissionDurationAdd, 0.0, false, 1, 0);
    Wait(7.0, c_timeGame);
    TransmissionWait(TransmissionLastSent(), 0.0);
    UnitSetPosition(gv_hERO_Raynor, PointFromId(2083), false);
    UnitSetPosition(gv_hERO_Instructor, PointFromId(2187), false);
    UnitSetFacing(gv_hERO_Instructor, PointGetFacing(PointFromId(2187)), 0.0);
    CameraApplyInfo(gv_pLAYER_01_USER, CameraInfoDefault(), 0.0, -1, 10.0, false);
    if ((libStEx_gf_TutorialCameraLocked() == true)) {
        CameraPan(gv_pLAYER_01_USER, UnitGetPosition(gv_hERO_Raynor), 0.0, -1, 10.0, false);
    }
    else {
        CameraPan(gv_pLAYER_01_USER, PointFromId(2174), 0.0, -1, 10.0, false);
    }
    libStEx_gf_TurnCinematicCameraOnOff(gv_pLAYER_01_USER, false);
    libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00301", c_transmissionDurationAdd, 0.0, false, 1, 0);
    TransmissionWait(TransmissionLastSent(), 1.0);
    UnitIssueOrder(gv_hERO_Raynor, OrderTargetingPoint(AbilityCommand("move", 0), PointFromId(2174)), c_orderQueueReplace);
    TransmissionWait(TransmissionLastSent(), 0.0);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
    gv_cinematicCompleted = true;
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_MidGarrisonCinematic_Init () {
    gt_MidGarrisonCinematic = TriggerCreate("gt_MidGarrisonCinematic_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MidGarrison Cinematic End
//--------------------------------------------------------------------------------------------------
bool gt_MidGarrisonCinematicEnd_Func (bool testConds, bool runActions) {
    // Variable Declarations
    fixed lv_fadeDuration;

    // Variable Initialization

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

    if ((gv_cinematicCompleted == false)) {
        lv_fadeDuration = 0.5;
        CinematicFade(false, lv_fadeDuration, c_fadeStyleNormal, ColorWithAlpha(0.00, 0.00, 0.00, 0.00), 0.0, true);
    }
    else {
    }
    SoundtrackStopCurrent(PlayerGroupAll(), c_soundtrackCategoryMusic, true);
    SoundtrackPlay(PlayerGroupAll(), c_soundtrackCategoryMusic, "Storm_Music_Tutorial_Alt1", c_soundtrackCueAny, c_soundtrackIndexAny, true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_MidGarrisonCinematicEnd_Init () {
    gt_MidGarrisonCinematicEnd = TriggerCreate("gt_MidGarrisonCinematicEnd_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MidGarrison Cleanup
//--------------------------------------------------------------------------------------------------
bool gt_MidGarrisonCleanup_Func (bool testConds, bool runActions) {
    // Variable Declarations
    fixed lv_fadeDuration;

    // Variable Initialization

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

    TriggerStop(gt_MidGarrisonCinematicMinionCamera);
    TriggerStop(gt_MidGarrisonCinematicSpawnOrderWave);
    TriggerStop(gt_MidGarrisonCinematicSpawnChaosWave);
    UnitGroupLoopBegin(gv_cinematicTempUnits);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        UnitRemove(UnitGroupLoopCurrent());
    }
    UnitGroupLoopEnd();
    UnitGroupLoopBegin(gv_cinematicHiddenUnits);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        libNtve_gf_ShowHideUnit(UnitGroupLoopCurrent(), true);
    }
    UnitGroupLoopEnd();
    UnitGroupLoopBegin(gv_cinematicPausedUnits);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        libNtve_gf_PauseUnit(UnitGroupLoopCurrent(), false);
    }
    UnitGroupLoopEnd();
    GameTimeOfDayPause(false);
    if ((gv_midGarrision_RaynorTeleportEffect != null)) {
        libNtve_gf_KillModel(gv_midGarrision_RaynorTeleportEffect);
    }
    else {
    }
    libNtve_gf_RestoreUnitSelection(gv_pLAYER_01_USER);
    VisExploreArea(gv_pLAYER_01_USER, RegionEntireMap(), true, false);
    if ((gv_cinematicCompleted == false)) {
        if ((libNtve_gf_UnitIsHidden(gv_hERO_Raynor) == true)) {
            libNtve_gf_ShowHideUnit(gv_hERO_Raynor, true);
        }
        else {
        }
        UnitSetPosition(gv_hERO_Raynor, PointFromId(2174), false);
        UnitIssueOrder(gv_hERO_Raynor, Order(AbilityCommand("stop", 0)), c_orderQueueReplace);
        if ((gv__2C_CoreReticle == null)) {
            libCore_gf_AttachReticleEffectAndTextTagOnUnit(2, 0, null, libGame_gv_teams[libGame_gv_teamChaosIndex_C].lv_core, "Ref_Center");
            gv__2C_CoreReticle = libNtve_gf_ActorLastCreated();
        }
        else {
        }
        libStEx_gf_TurnCinematicCameraOnOff(gv_pLAYER_01_USER, false);
        CameraApplyInfo(gv_pLAYER_01_USER, CameraInfoDefault(), 0.0, -1, 10.0, false);
    }
    else {
    }
    VisRevealArea(gv_pLAYER_01_USER, RegionFromId(6), 0.0, false);
    VisExploreArea(gv_pLAYER_01_USER, RegionFromId(5), true, false);
    UnitSelect(gv_hERO_Raynor, gv_pLAYER_01_USER, true);
    libNtve_gf_UnitRemoveCooldown(gv_hERO_Raynor, "Abil/RaynorPenetratingRound");
    libNtve_gf_UnitRemoveCooldown(gv_hERO_Raynor, "Abil/RaynorInspire");
    libNtve_gf_ChangeUnitDamage(gv_hERO_Raynor, 1, 4);
    Wait(0.5, c_timeReal);
    libNtve_gf_MakeUnitUncommandable(gv_hERO_Raynor, false);
    UnitSetState(gv_hERO_Raynor, c_unitStateFidget, true);
    if ((gv_cinematicCompleted == true)) {
        lv_fadeDuration = 1.0;
        libStEx_gf_CinematicModeTutorial(false, PlayerGroupAll(), 1.0);
        libNtve_gf_GlobalCinematicSetting(false);
    }
    else {
        lv_fadeDuration = 1.0;
        CinematicFade(true, lv_fadeDuration, c_fadeStyleNormal, ColorWithAlpha(0.00, 0.00, 0.00, 0.00), 0.0, false);
        libStEx_gf_CinematicModeTutorial(false, PlayerGroupAll(), 1.0);
        libNtve_gf_GlobalCinematicSetting(false);
        if ((libStEx_gf_TutorialCameraLocked() == true)) {
            libNtve_gf_SwooshCamera(gv_pLAYER_01_USER, ((CameraInfoGetValue(CameraInfoDefault(), c_cameraValueDistance)) + 8.0), CameraInfoGetValue(CameraInfoDefault(), c_cameraValueDistance), UnitGetPosition(gv_hERO_Raynor), lv_fadeDuration);
        }
        else {
            libNtve_gf_SwooshCamera(gv_pLAYER_01_USER, ((CameraInfoGetValue(CameraInfoDefault(), c_cameraValueDistance)) + 8.0), CameraInfoGetValue(CameraInfoDefault(), c_cameraValueDistance), PointFromId(2174), lv_fadeDuration);
        }
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_MidGarrisonCleanup_Init () {
    gt_MidGarrisonCleanup = TriggerCreate("gt_MidGarrisonCleanup_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MidGarrison Cinematic Spawn Chaos Wave
//--------------------------------------------------------------------------------------------------
bool gt_MidGarrisonCinematicSpawnChaosWave_Func (bool testConds, bool runActions) {
    unitgroup autoBF91B920_g;
    int autoBF91B920_u;

    // Variable Declarations
    unit lv_indexMinion;

    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    libNtve_gf_CreateUnitsAtPoint2(3, "FootmanMinion", c_unitCreateIgnorePlacement, gv_pLAYER_12_CHAOS, PointFromId(23));
    UnitGroupAddUnitGroup(gv_midGarrision_ChaosWave, UnitLastCreatedGroup());
    UnitGroupAddUnitGroup(gv_cinematicTempUnits, UnitLastCreatedGroup());
    gf_MidGarrisonCinematicSendChaosWave(UnitLastCreatedGroup());
    Wait(0.75, c_timeGame);
    libNtve_gf_CreateUnitsAtPoint2(1, "WizardMinion", c_unitCreateIgnorePlacement, gv_pLAYER_12_CHAOS, PointFromId(23));
    UnitGroupAddUnitGroup(gv_midGarrision_ChaosWave, UnitLastCreatedGroup());
    UnitGroupAddUnitGroup(gv_cinematicTempUnits, UnitLastCreatedGroup());
    gf_MidGarrisonCinematicSendChaosWave(UnitLastCreatedGroup());
    Wait(0.75, c_timeGame);
    libNtve_gf_CreateUnitsAtPoint2(3, "RangedMinion", c_unitCreateIgnorePlacement, gv_pLAYER_12_CHAOS, PointFromId(23));
    UnitGroupAddUnitGroup(gv_midGarrision_ChaosWave, UnitLastCreatedGroup());
    UnitGroupAddUnitGroup(gv_cinematicTempUnits, UnitLastCreatedGroup());
    gf_MidGarrisonCinematicSendChaosWave(UnitLastCreatedGroup());
    autoBF91B920_g = gv_midGarrision_ChaosWave;
    autoBF91B920_u = 1;
    for ( ; autoBF91B920_u <= UnitGroupCount(autoBF91B920_g, c_unitCountAll) ; autoBF91B920_u += BoolToInt(lv_indexMinion == UnitGroupUnit(autoBF91B920_g, autoBF91B920_u)) ) {
        lv_indexMinion = UnitGroupUnit(autoBF91B920_g, autoBF91B920_u);
        libNtve_gf_ChangeUnitDamage(lv_indexMinion, 0, 2);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_MidGarrisonCinematicSpawnChaosWave_Init () {
    gt_MidGarrisonCinematicSpawnChaosWave = TriggerCreate("gt_MidGarrisonCinematicSpawnChaosWave_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MidGarrison Cinematic Spawn Order Wave
//--------------------------------------------------------------------------------------------------
bool gt_MidGarrisonCinematicSpawnOrderWave_Func (bool testConds, bool runActions) {
    unitgroup auto2C61BB4A_g;
    int auto2C61BB4A_u;

    // Variable Declarations
    unit lv_indexMinion;

    // Variable Initialization

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

    libNtve_gf_CreateUnitsAtPoint2(1, "FootmanMinion", c_unitCreateIgnorePlacement, gv_pLAYER_11_ORDER, PointFromId(2166));
    UnitGroupAddUnitGroup(gv_midGarrision_OrdersWave, UnitLastCreatedGroup());
    UnitGroupAddUnitGroup(gv_cinematicTempUnits, UnitLastCreatedGroup());
    libNtve_gf_CreateUnitsAtPoint2(1, "FootmanMinion", c_unitCreateIgnorePlacement, gv_pLAYER_11_ORDER, PointFromId(2165));
    UnitGroupAddUnitGroup(gv_midGarrision_OrdersWave, UnitLastCreatedGroup());
    UnitGroupAddUnitGroup(gv_cinematicTempUnits, UnitLastCreatedGroup());
    libNtve_gf_CreateUnitsAtPoint2(1, "FootmanMinion", c_unitCreateIgnorePlacement, gv_pLAYER_11_ORDER, PointFromId(2167));
    UnitGroupAddUnitGroup(gv_midGarrision_OrdersWave, UnitLastCreatedGroup());
    UnitGroupAddUnitGroup(gv_cinematicTempUnits, UnitLastCreatedGroup());
    libNtve_gf_CreateUnitsAtPoint2(1, "WizardMinion", c_unitCreateIgnorePlacement, gv_pLAYER_11_ORDER, PointFromId(2168));
    UnitGroupAddUnitGroup(gv_midGarrision_OrdersWave, UnitLastCreatedGroup());
    UnitGroupAddUnitGroup(gv_cinematicTempUnits, UnitLastCreatedGroup());
    libNtve_gf_CreateUnitsAtPoint2(1, "RangedMinion", c_unitCreateIgnorePlacement, gv_pLAYER_11_ORDER, PointFromId(2169));
    UnitGroupAddUnitGroup(gv_midGarrision_OrdersWave, UnitLastCreatedGroup());
    UnitGroupAddUnitGroup(gv_cinematicTempUnits, UnitLastCreatedGroup());
    libNtve_gf_CreateUnitsAtPoint2(1, "RangedMinion", c_unitCreateIgnorePlacement, gv_pLAYER_11_ORDER, PointFromId(1193));
    UnitGroupAddUnitGroup(gv_midGarrision_OrdersWave, UnitLastCreatedGroup());
    UnitGroupAddUnitGroup(gv_cinematicTempUnits, UnitLastCreatedGroup());
    libNtve_gf_CreateUnitsAtPoint2(1, "RangedMinion", c_unitCreateIgnorePlacement, gv_pLAYER_11_ORDER, PointFromId(1194));
    UnitGroupAddUnitGroup(gv_midGarrision_OrdersWave, UnitLastCreatedGroup());
    UnitGroupAddUnitGroup(gv_cinematicTempUnits, UnitLastCreatedGroup());
    auto2C61BB4A_g = gv_midGarrision_OrdersWave;
    auto2C61BB4A_u = 1;
    for ( ; auto2C61BB4A_u <= UnitGroupCount(auto2C61BB4A_g, c_unitCountAll) ; auto2C61BB4A_u += BoolToInt(lv_indexMinion == UnitGroupUnit(auto2C61BB4A_g, auto2C61BB4A_u)) ) {
        lv_indexMinion = UnitGroupUnit(auto2C61BB4A_g, auto2C61BB4A_u);
        libNtve_gf_ChangeUnitDamage(lv_indexMinion, 0, 2);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_MidGarrisonCinematicSpawnOrderWave_Init () {
    gt_MidGarrisonCinematicSpawnOrderWave = TriggerCreate("gt_MidGarrisonCinematicSpawnOrderWave_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MidGarrison Cinematic Minion Camera
//--------------------------------------------------------------------------------------------------
bool gt_MidGarrisonCinematicMinionCamera_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    CameraApplyInfo(gv_pLAYER_01_USER, CameraInfoFromId(966), 10.0, -1, 10, true);
    Wait(3.5, c_timeGame);
    CameraApplyInfo(gv_pLAYER_01_USER, CameraInfoFromId(1195), 10.0, -1, 10, true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_MidGarrisonCinematicMinionCamera_Init () {
    gt_MidGarrisonCinematicMinionCamera = TriggerCreate("gt_MidGarrisonCinematicMinionCamera_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MidTowerDanger Q
//--------------------------------------------------------------------------------------------------
bool gt_MidTowerDangerQ_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerQueueEnter();
    TriggerExecute(gt_MidTowerDangerSetup, true, true);
    TriggerExecute(gt_MidTowerDangerCinematic, true, true);
    TriggerExecute(gt_MidTowerDangerCinematicEnd, true, true);
    TriggerExecute(gt_MidTowerDangerCleanup, true, true);
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_MidTowerDangerQ_Init () {
    gt_MidTowerDangerQ = TriggerCreate("gt_MidTowerDangerQ_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MidTowerDanger Setup
//--------------------------------------------------------------------------------------------------
bool gt_MidTowerDangerSetup_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_itUnit;

    // Variable Initialization

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

    libStEx_gf_ClearHintMessage();
    libStEx_gf_CinematicModeTutorial(true, PlayerGroupAll(), 1.0);
    libStEx_gf_TurnCinematicCameraOnOff(gv_pLAYER_01_USER, true);
    GameTimeOfDayPause(true);
    gv_cinematicHiddenUnits = UnitGroupEmpty();
    gv_cinematicTempUnits = UnitGroupEmpty();
    UnitIssueOrder(gv_hERO_Raynor, Order(AbilityCommand("move", 2)), c_orderQueueReplace);
    libNtve_gf_MakeUnitUncommandable(gv_hERO_Raynor, true);
    libNtve_gf_PauseUnit(gv_hERO_Raynor, true);
    UnitSetState(gv_hERO_Raynor, c_unitStateFidget, false);
    UnitSetPosition(gv_hERO_Stitch, PointFromId(1197), false);
    UnitSetFacing(gv_hERO_Stitch, PointGetFacing(PointFromId(1197)), 0.0);
    libNtve_gf_MakeUnitInvulnerable(gv_hERO_Stitch, false);
    UnitIssueOrder(gv_hERO_Stitch, OrderTargetingPoint(AbilityCommand("move", 0), PointFromId(1200)), c_orderQueueReplace);
    libNtve_gf_ChangeUnitDamage(gv_hERO_Stitch, 0, 1);
    libNtve_gf_ChangeUnitDamage(gv_hERO_Stitch, 1, 1);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_MidTowerDangerSetup_Init () {
    gt_MidTowerDangerSetup = TriggerCreate("gt_MidTowerDangerSetup_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MidTowerDanger Cinematic
//--------------------------------------------------------------------------------------------------
bool gt_MidTowerDangerCinematic_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    SoundtrackPlay(PlayerGroupAll(), c_soundtrackCategoryMusic, "Storm_Music_Tutorial_Cutscene_Stitches", c_soundtrackCueAny, c_soundtrackIndexAny, false);
    CameraPan(gv_pLAYER_01_USER, CameraInfoGetTarget(CameraInfoFromId(1230)), 1.5, -1, 10.0, false);
    Wait(1.0, c_timeGame);
    libNtve_gf_PlayAnimation(libNtve_gf_MainActorofUnit(gv_hERO_Stitch), c_animNameDefault, "Taunt", c_animFlagNonLooping, c_animTimeDefault);
    Wait(1.0, c_timeReal);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(0, PlayerGroupAll());
    libCore_gf_SendTransmissionCampaign(gv_hERO_Stitch, "TutorialVO|Line00246", c_transmissionDurationAdd, 0.0, true, 1, 0);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
    UnitIssueOrder(gv_hERO_Stitch, OrderTargetingUnit(AbilityCommand("attack", 0), UnitFromId(110)), c_orderQueueReplace);
    Wait(1.0, c_timeReal);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(0, PlayerGroupAll());
    libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00303", c_transmissionDurationAdd, 0.0, false, 1, 0);
    Wait(1.0, c_timeGame);
    TriggerExecute(gt__2BStartMinionSystem, true, false);
    Wait(1.0, c_timeGame);
    CameraPan(gv_pLAYER_01_USER, UnitGetPosition(gv_hERO_Raynor), 3.0, -1, 10.0, false);
    Wait(2.0, c_timeGame);
    UnitSetPropertyFixed(gv_hERO_Stitch, c_unitPropLife, 1000.0);
    libNtve_gf_ChangeUnitDamage(gv_hERO_Stitch, 0, 0);
    libNtve_gf_ChangeUnitDamage(gv_hERO_Stitch, 1, 0);
    Wait(1.0, c_timeGame);
    libNtve_gv__CineTransitionStyle = 1;
    libStEx_gf_CinematicModeTutorial(false, PlayerGroupAll(), 1.0);
    libStEx_gf_TurnCinematicCameraOnOff(gv_pLAYER_01_USER, false);
    libNtve_gv__CineTransitionStyle = 0;
    libNtve_gf_PauseUnit(gv_hERO_Raynor, false);
    libNtve_gf_MakeUnitUncommandable(gv_hERO_Raynor, false);
    libNtve_gf_MakeUnitInvulnerable(gv_hERO_Raynor, false);
    UnitSetState(gv_hERO_Raynor, c_unitStateFidget, true);
    TransmissionWait(TransmissionLastSent(), 0.0);
    libCore_gf_SetAllSoundChannelVolumesStandardTiming(2, PlayerGroupAll());
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_MidTowerDangerCinematic_Init () {
    gt_MidTowerDangerCinematic = TriggerCreate("gt_MidTowerDangerCinematic_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MidTowerDanger Cinematic End
//--------------------------------------------------------------------------------------------------
bool gt_MidTowerDangerCinematicEnd_Func (bool testConds, bool runActions) {
    // Variable Declarations
    fixed lv_fadeDuration;

    // Variable Initialization

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

    SoundtrackStopCurrent(PlayerGroupAll(), c_soundtrackCategoryMusic, true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_MidTowerDangerCinematicEnd_Init () {
    gt_MidTowerDangerCinematicEnd = TriggerCreate("gt_MidTowerDangerCinematicEnd_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MidTowerDanger Cleanup
//--------------------------------------------------------------------------------------------------
bool gt_MidTowerDangerCleanup_Func (bool testConds, bool runActions) {
    // Variable Declarations
    fixed lv_fadeDuration;

    // Variable Initialization

    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_MidTowerDangerCleanup_Init () {
    gt_MidTowerDangerCleanup = TriggerCreate("gt_MidTowerDangerCleanup_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MidDeath Q
//--------------------------------------------------------------------------------------------------
bool gt_MidDeathQ_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerQueueEnter();
    TriggerExecute(gt_MidDeathSetup, true, true);
    TriggerExecute(gt_MidDeathCinematic, true, true);
    TriggerExecute(gt_MidDeathCinematicEnd, true, true);
    TriggerExecute(gt_MidDeathCleanup, true, true);
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_MidDeathQ_Init () {
    gt_MidDeathQ = TriggerCreate("gt_MidDeathQ_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MidDeath Setup
//--------------------------------------------------------------------------------------------------
bool gt_MidDeathSetup_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    libStEx_gf_ClearHintMessage();
    CinematicFade(false, 1.0, c_fadeStyleNormal, ColorWithAlpha(0.00, 0.00, 0.00, 0.00), 0.0, false);
    UISetMode(PlayerGroupAll(), c_uiModeFullscreen, 1.0);
    Wait(1.0, c_timeGame);
    libStEx_gf_CinematicModeTutorial(true, PlayerGroupAll(), 0.0);
    libNtve_gf_GlobalCinematicSetting(true);
    libStEx_gf_TurnCinematicCameraOnOff(gv_pLAYER_01_USER, true);
    GameTimeOfDayPause(true);
    gv_minion_SpawnPaused = true;
    UnitGroupLoopBegin(UnitGroup(null, c_playerAny, null, UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32))), 0));
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        if ((libNtve_gf_UnitIsPaused(UnitGroupLoopCurrent()) == false) && (UnitGroupLoopCurrent() != UnitFromId(37)) && (UnitGroupLoopCurrent() != UnitFromId(39)) && (UnitGroupLoopCurrent() != UnitFromId(955)) && (UnitGroupLoopCurrent() != UnitFromId(1543))) {
            UnitGroupAdd(gv_cinematicPausedUnits, UnitGroupLoopCurrent());
            libNtve_gf_PauseUnit(UnitGroupLoopCurrent(), true);
        }
        else {
        }
    }
    UnitGroupLoopEnd();
    gv_cinematicHiddenUnits = UnitGroupEmpty();
    UnitGroupAddUnitGroup(gv_cinematicHiddenUnits, UnitGroup(null, gv_pLAYER_11_ORDER, RegionFromId(34), UnitFilter((1 << c_targetFilterBiological), 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0));
    UnitGroupAddUnitGroup(gv_cinematicHiddenUnits, UnitGroup(null, gv_pLAYER_12_CHAOS, RegionFromId(34), UnitFilter((1 << c_targetFilterBiological), 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0));
    UnitGroupAdd(gv_cinematicHiddenUnits, gv_hERO_Raynor);
    gv_cinematicTempUnits = UnitGroupEmpty();
    UnitGroupLoopBegin(gv_cinematicHiddenUnits);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        libNtve_gf_ShowHideUnit(UnitGroupLoopCurrent(), false);
    }
    UnitGroupLoopEnd();
    UnitSetPropertyFixed(UnitFromId(37), c_unitPropEnergyPercent, 100.0);
    libNtve_gf_CreateUnitsAtPoint2(1, "RangedMinion", 0, gv_pLAYER_11_ORDER, PointFromId(1211));
    UnitGroupAdd(gv_cinematicTempUnits, UnitLastCreated());
    UnitGroupAdd(gv_midDeath_MinionsLeft, UnitLastCreated());
    libNtve_gf_ChangeUnitDamage(UnitLastCreated(), 0, 3);
    libNtve_gf_ChangeUnitDamage(UnitLastCreated(), 1, 1);
    libNtve_gf_TurnAnimationPropertiesOn(libNtve_gf_MainActorofUnit(UnitLastCreated()), "Dance");
    libNtve_gf_CreateUnitsAtPoint2(1, "RangedMinion", 0, gv_pLAYER_11_ORDER, PointFromId(1212));
    UnitGroupAdd(gv_cinematicTempUnits, UnitLastCreated());
    UnitGroupAdd(gv_midDeath_MinionsLeft, UnitLastCreated());
    libNtve_gf_ChangeUnitDamage(UnitLastCreated(), 0, 0);
    libNtve_gf_ChangeUnitDamage(UnitLastCreated(), 1, 1);
    libNtve_gf_TurnAnimationPropertiesOn(libNtve_gf_MainActorofUnit(UnitLastCreated()), "Dance");
    UnitSetPropertyFixed(UnitFromId(39), c_unitPropEnergyPercent, 100.0);
    libNtve_gf_CreateUnitsAtPoint2(1, "RangedMinion", 0, gv_pLAYER_11_ORDER, PointFromId(1216));
    UnitGroupAdd(gv_cinematicTempUnits, UnitLastCreated());
    UnitGroupAdd(gv_midDeath_MinionsRight, UnitLastCreated());
    libNtve_gf_ChangeUnitDamage(UnitLastCreated(), 0, 3);
    libNtve_gf_ChangeUnitDamage(UnitLastCreated(), 1, 1);
    libNtve_gf_TurnAnimationPropertiesOn(libNtve_gf_MainActorofUnit(UnitLastCreated()), "Dance");
    libNtve_gf_CreateUnitsAtPoint2(1, "FlagBearerMinion", 0, gv_pLAYER_11_ORDER, PointFromId(1217));
    UnitGroupAdd(gv_cinematicTempUnits, UnitLastCreated());
    UnitGroupAdd(gv_midDeath_MinionsRight, UnitLastCreated());
    libNtve_gf_ChangeUnitDamage(UnitLastCreated(), 0, 0);
    libNtve_gf_ChangeUnitDamage(UnitLastCreated(), 1, 1);
    libNtve_gf_TurnAnimationPropertiesOn(libNtve_gf_MainActorofUnit(UnitLastCreated()), "Dance");
    UnitRemove(gv_hERO_Stitch);
    UnitRemove(gv_hERO_Diablo);
    libNtve_gf_ShowHideUnit(gv_hERO_Raynor, false);
    libNtve_gf_CreateUnitsAtPoint2(1, "HeroRaynor", c_unitCreateIgnorePlacement, gv_pLAYER_01_USER, PointFromId(1262));
    gv_midDeath_Raynor = UnitLastCreated();
    UnitGroupAdd(gv_cinematicTempUnits, UnitLastCreated());
    libNtve_gf_ChangeUnitDamage(gv_midDeath_Raynor, 1, 1);
    libNtve_gf_ChangeUnitDamage(gv_midDeath_Raynor, 0, 1);
    UnitSetState(gv_midDeath_Raynor, c_unitStateFidget, false);
    libNtve_gf_PauseUnit(gv_midDeath_Raynor, true);
    libNtve_gf_CreateUnitsAtPoint2(1, "HeroStitches", c_unitCreateIgnorePlacement, gv_pLAYER_07_STITCHES, PointFromId(1218));
    gv_midDeath_Stitches = UnitLastCreated();
    UnitGroupAdd(gv_cinematicTempUnits, UnitLastCreated());
    libNtve_gf_PauseUnit(gv_midDeath_Stitches, true);
    libNtve_gf_ShowHideUnit(UnitLastCreated(), false);
    libNtve_gf_CreateUnitsAtPoint2(1, "HeroDiablo", c_unitCreateIgnorePlacement, gv_pLAYER_06_DIABLO, PointFromId(1219));
    gv_midDeath_Diablo = UnitLastCreated();
    UnitGroupAdd(gv_cinematicTempUnits, UnitLastCreated());
    libNtve_gf_PauseUnit(gv_midDeath_Diablo, true);
    libNtve_gf_ShowHideUnit(UnitLastCreated(), false);
    if ((UnitIsAlive(UnitFromId(955)) == true)) {
        UnitRemove(UnitFromId(955));
        libNtve_gf_ShowHideUnit(gv_midDeath_TownGate, true);
        UnitGroupAdd(gv_cinematicTempUnits, gv_midDeath_TownGate);
    }
    else {
        UnitRemove(gv_midDeath_TownGate);
        gv_midDeath_TownGate = null;
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_MidDeathSetup_Init () {
    gt_MidDeathSetup = TriggerCreate("gt_MidDeathSetup_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MidDeath Cinematic
//--------------------------------------------------------------------------------------------------
bool gt_MidDeathCinematic_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_target;

    // Variable Initialization

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

    SoundtrackPlay(PlayerGroupAll(), c_soundtrackCategoryMusic, "Storm_Music_Tutorial_Cutscene_Stitches", c_soundtrackCueAny, c_soundtrackIndexAny, false);
    CameraApplyInfo(gv_pLAYER_01_USER, CameraInfoFromId(1221), 0.0, -1, 10.0, true);
    TriggerSkippableBegin(PlayerGroupAll(), 0, null, true, false);
    gv_cinematicCompleted = false;
    CinematicFade(true, 1.0, c_fadeStyleNormal, ColorWithAlpha(0.00, 0.00, 0.00, 0.00), 0.0, false);
    Wait(1.0, c_timeReal);
    libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00356", c_transmissionDurationAdd, 0.0, true, 1, 0);
    libCore_gf_SendTransmissionCampaign(gv_midDeath_Raynor, "TutorialVO|Line00357", c_transmissionDurationAdd, 0.0, true, 1, 0);
    if ((gv_midDeath_TownGate != null)) {
        libNtve_gf_PauseUnit(gv_midDeath_Raynor, false);
        libNtve_gf_ChangeUnitDamage(gv_midDeath_Raynor, 1, 3);
        UnitIssueOrder(gv_midDeath_Raynor, OrderTargetingPoint(AbilityCommand("RaynorPenetratingRound", 0), UnitGetPosition(gv_midDeath_TownGate)), c_orderQueueReplace);
        UnitSetPropertyFixed(gv_midDeath_TownGate, c_unitPropLife, 50.0);
        while (!((UnitIsAlive(gv_midDeath_TownGate) == false))) {
            Wait(0.0625, c_timeGame);
        }
        libNtve_gf_PauseUnit(gv_midDeath_Raynor, true);
        Wait(2.0, c_timeGame);
    }
    else {
    }
    UnitSetPosition(gv_midDeath_Diablo, PointFromId(1199), false);
    UnitIssueOrder(gv_midDeath_Diablo, OrderTargetingPoint(AbilityCommand("move", 0), PointFromId(1219)), c_orderQueueReplace);
    UnitIssueOrder(gv_midDeath_Diablo, Order(AbilityCommand("move", 2)), c_orderQueueAddToEnd);
    libNtve_gf_ShowHideUnit(gv_midDeath_Diablo, true);
    libNtve_gf_PauseUnit(gv_midDeath_Diablo, false);
    CameraApplyInfo(gv_pLAYER_01_USER, CameraInfoFromId(1198), 0.0, -1, 10.0, true);
    Wait(1.0, c_timeGame);
    libNtve_gf_PlayAnimation(libNtve_gf_MainActorofUnit(gv_midDeath_Diablo), c_animNameDefault, "Spell C", c_animFlagNonLooping, c_animTimeDefault);
    libCore_gf_SendTransmissionCampaign(gv_midDeath_Diablo, "TutorialVO|Line00358", c_transmissionDurationAdd, 0.0, true, 1, 0);
    CameraApplyInfo(gv_pLAYER_01_USER, CameraInfoFromId(1229), 0.0, -1, 10.0, true);
    libCore_gf_SendTransmissionCampaign(gv_midDeath_Raynor, "TutorialVO|Line00359", c_transmissionDurationAdd, 0.0, true, 1, 0);
    libNtve_gf_ShowHideUnit(gv_midDeath_Stitches, true);
    libNtve_gf_PauseUnit(gv_midDeath_Stitches, false);
    UnitIssueOrder(gv_midDeath_Stitches, OrderTargetingPoint(AbilityCommand("move", 0), PointFromId(1259)), c_orderQueueReplace);
    UnitIssueOrder(gv_midDeath_Stitches, Order(AbilityCommand("move", 2)), c_orderQueueAddToEnd);
    CameraPan(gv_pLAYER_01_USER, CameraInfoGetTarget(CameraInfoFromId(1222)), 1.5, -1, 10.0, false);
    Wait(1.0, c_timeGame);
    libCore_gf_SendTransmissionCampaign(gv_midDeath_Stitches, "TutorialVO|Line00360", c_transmissionDurationAdd, 0.0, true, 1, 0);
    libCore_gf_SendTransmissionCampaign(gv_midDeath_Raynor, "TutorialVO|Line00361", c_transmissionDurationAdd, 0.0, true, 1, 0);
    CameraApplyInfo(gv_pLAYER_01_USER, CameraInfoFromId(1261), 0.0, -1, 10.0, true);
    libCore_gf_SendTransmissionCampaign(gv_midDeath_Diablo, "TutorialVO|Line00362", c_transmissionDurationAdd, 0.0, true, 1, 0);
    UnitIssueOrder(gv_midDeath_Diablo, OrderTargetingUnit(AbilityCommand("DiabloShadowCharge", 0), gv_midDeath_Raynor), c_orderQueueReplace);
    UnitIssueOrder(gv_midDeath_Diablo, OrderTargetingUnit(AbilityCommand("attack", 0), gv_midDeath_Raynor), c_orderQueueAddToEnd);
    UnitSetPosition(gv_midDeath_Raynor, PointFromId(1220), false);
    CameraPan(gv_pLAYER_01_USER, CameraInfoGetTarget(CameraInfoFromId(1222)), 4.0, -1, 10.0, false);
    Wait(2.0, c_timeGame);
    UnitIssueOrder(gv_midDeath_Stitches, OrderTargetingPoint(AbilityCommand("move", 0), PointFromId(1223)), c_orderQueueReplace);
    UnitIssueOrder(gv_midDeath_Stitches, OrderTargetingPoint(AbilityCommand("StitchesHook", 0), UnitGetPosition(gv_midDeath_Raynor)), c_orderQueueAddToEnd);
    UnitIssueOrder(gv_midDeath_Stitches, OrderTargetingUnit(AbilityCommand("attack", 0), gv_midDeath_Raynor), c_orderQueueAddToEnd);
    libNtve_gf_PauseUnit(gv_midDeath_Raynor, false);
    Wait(1.0, c_timeGame);
    UnitIssueOrder(UnitFromId(1543), OrderTargetingUnit(AbilityCommand("attack", 0), gv_midDeath_Raynor), c_orderQueueAddToEnd);
    SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryVoice, 100.0, 0.5);
    Wait(1.0, c_timeGame);
    UnitIssueOrder(gv_midDeath_Raynor, OrderTargetingUnit(AbilityCommand("attack", 0), gv_midDeath_Stitches), c_orderQueueReplace);
    UnitIssueOrder(UnitFromId(1543), OrderTargetingUnit(AbilityCommand("attack", 0), gv_midDeath_Raynor), c_orderQueueAddToEnd);
    Wait(2.0, c_timeGame);
    libNtve_gf_ChangeUnitDamage(gv_midDeath_Diablo, 1, 3);
    libNtve_gf_ChangeUnitDamage(gv_midDeath_Stitches, 1, 3);
    libNtve_gf_ChangeUnitDamage(gv_midDeath_Raynor, 0, 3);
    libNtve_gf_ChangeUnitDamage(gv_midDeath_Raynor, 1, 1);
    UnitSetPropertyFixed(gv_midDeath_Raynor, c_unitPropLife, 1.0);
    while (!((UnitIsAlive(gv_midDeath_Raynor) == false))) {
        Wait(0.0625, c_timeGame);
    }
    libGame_gf_SpecialLightingEventStart("Storm_Dead", PlayerGroupAll(), 1.0);
    Wait(2.0, c_timeGame);
    SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryVoice, 0.0, 1.5);
    CinematicFade(false, 1.5, c_fadeStyleNormal, Color(0.00, 0.00, 0.00), 0.0, true);
    CameraApplyInfo(gv_pLAYER_01_USER, CameraInfoDefault(), 0.0, -1, 10.0, true);
    CameraPan(gv_pLAYER_01_USER, UnitGetPosition(UnitFromId(156)), 0.0, -1, 10.0, false);
    CinematicFade(true, 1.0, c_fadeStyleNormal, Color(0.00, 0.00, 0.00), 0.0, true);
    libCore_gf_SendTransmissionCampaign(gv_hERO_Diablo, "TutorialVO|Line00363", c_transmissionDurationAdd, 0.0, true, 1, 0);
    libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00307", c_transmissionDurationAdd, 0.0, true, 1, 0);
    libCore_gf_SendTransmissionCampaign(gv_hERO_Instructor, "TutorialVO|Line00308", c_transmissionDurationAdd, 0.0, true, 1, 0);
    libCore_gf_SendTransmissionCampaign(gv_hERO_Raynor, "TutorialVO|Line00309", c_transmissionDurationAdd, 0.0, true, 1, 0);
    Wait(1.0, c_timeGame);
    gv_cinematicCompleted = true;
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_MidDeathCinematic_Init () {
    gt_MidDeathCinematic = TriggerCreate("gt_MidDeathCinematic_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MidDeath Cinematic End
//--------------------------------------------------------------------------------------------------
bool gt_MidDeathCinematicEnd_Func (bool testConds, bool runActions) {
    // Variable Declarations
    fixed lv_fadeDuration;

    // Variable Initialization

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

    if ((gv_cinematicCompleted == false)) {
        lv_fadeDuration = 0.5;
    }
    else {
        lv_fadeDuration = 1.0;
    }
    CinematicFade(false, lv_fadeDuration, c_fadeStyleNormal, ColorWithAlpha(0.00, 0.00, 0.00, 0.00), 0.0, true);
    SoundtrackStopCurrent(PlayerGroupAll(), c_soundtrackCategoryMusic, true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_MidDeathCinematicEnd_Init () {
    gt_MidDeathCinematicEnd = TriggerCreate("gt_MidDeathCinematicEnd_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: MidDeath Cleanup
//--------------------------------------------------------------------------------------------------
bool gt_MidDeathCleanup_Func (bool testConds, bool runActions) {
    // Variable Declarations
    fixed lv_fadeDuration;

    // Variable Initialization

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

    UnitGroupLoopBegin(gv_cinematicTempUnits);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        UnitRemove(UnitGroupLoopCurrent());
    }
    UnitGroupLoopEnd();
    UnitGroupLoopBegin(gv_cinematicHiddenUnits);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        libNtve_gf_ShowHideUnit(UnitGroupLoopCurrent(), true);
    }
    UnitGroupLoopEnd();
    UnitGroupLoopBegin(gv_cinematicPausedUnits);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        libNtve_gf_PauseUnit(UnitGroupLoopCurrent(), false);
    }
    UnitGroupLoopEnd();
    libNtve_gf_PauseUnit(gv_hERO_Raynor, false);
    GameTimeOfDayPause(false);
    gv_minion_SpawnPaused = false;
    libNtve_gf_RestoreUnitSelection(gv_pLAYER_01_USER);
    VisExploreArea(gv_pLAYER_01_USER, RegionEntireMap(), false, false);
    CameraApplyInfo(1, CameraInfoDefault(), 0.0, -1, 10.0, false);
    CameraPan(gv_pLAYER_01_USER, UnitGetPosition(UnitFromId(156)), 0.0, -1, 10.0, false);
    libStEx_gf_TurnCinematicCameraOnOff(gv_pLAYER_01_USER, false);
    libGame_gf_SpecialLightingEventEnd("Storm_Dead", libCore_gv_playerGroupFromPlayer[gv_pLAYER_01_USER], 0.0);
    UnitRemove(gv_hERO_Raynor);
    UnitRemove(gv_hERO_Instructor);
    UnitRemove(gv_hERO_Stitch);
    UnitRemove(gv_hERO_Diablo);
    gf_SpawnRaynor(PointFromId(1225), false);
    libGame_gf_SpawnHero(gv_pLAYER_02_UTHER, libStEx_gf_HeroIndex("Uther"), PointFromId(2187));
    libGame_gf_SpawnHero(gv_pLAYER_06_DIABLO, libStEx_gf_HeroIndex("Diablo"), PlayerStartLocation(gv_pLAYER_06_DIABLO));
    libGame_gf_SpawnHero(gv_pLAYER_07_STITCHES, libStEx_gf_HeroIndex("Stitches"), PlayerStartLocation(gv_pLAYER_07_STITCHES));
    UnitAbilityShow(gv_hERO_Raynor, "Mount", false);
    UnitXPGainEnable(gv_hERO_Raynor, null, true);
    UnitKill(gv_hERO_Raynor);
    libNtve_gf_ChangeUnitDamage(gv_hERO_Raynor, 0, 2);
    libNtve_gf_ChangeUnitDamage(gv_hERO_Raynor, 1, 0);
    gv_hERO_Instructor = libGame_gv_players[gv_pLAYER_02_UTHER].lv_heroUnit;
    gv_hERO_Diablo = libGame_gv_players[gv_pLAYER_06_DIABLO].lv_heroUnit;
    gv_hERO_Stitch = libGame_gv_players[gv_pLAYER_07_STITCHES].lv_heroUnit;
    libAIAI_gf_HeroAIDisableAIForPlayer(gv_pLAYER_02_UTHER);
    libAIAI_gf_HeroAIDisableAIForPlayer(gv_pLAYER_06_DIABLO);
    libAIAI_gf_HeroAIEnableAIForPlayer(gv_pLAYER_07_STITCHES);
    libAIAI_gf_HeroAISetAIDifficultyLevel(gv_pLAYER_07_STITCHES, 1);
    UnitXPGainEnable(gv_hERO_Instructor, null, true);
    UnitXPGainEnable(gv_hERO_Diablo, null, true);
    UnitXPGainEnable(gv_hERO_Stitch, null, true);
    PlayerSetState(gv_pLAYER_01_USER, c_playerStateXPGain, true);
    UnitSetPropertyFixed(UnitFromId(37), c_unitPropEnergyPercent, 100.0);
    UnitSetPropertyFixed(UnitFromId(39), c_unitPropEnergyPercent, 100.0);
    UnitRemove(UnitFromId(712));
    UnitRemove(UnitFromId(707));
    Wait(0.5, c_timeReal);
    if ((gv_cinematicCompleted == true)) {
        lv_fadeDuration = 1.5;
    }
    else {
        lv_fadeDuration = 1.0;
    }
    CinematicFade(true, lv_fadeDuration, c_fadeStyleNormal, ColorWithAlpha(0.00, 0.00, 0.00, 0.00), 0.0, false);
    libStEx_gf_CinematicModeTutorial(false, PlayerGroupAll(), 1.0);
    libNtve_gf_GlobalCinematicSetting(false);
    libNtve_gf_SwooshCamera(gv_pLAYER_01_USER, ((CameraInfoGetValue(CameraInfoDefault(), c_cameraValueDistance)) + 8.0), CameraInfoGetValue(CameraInfoDefault(), c_cameraValueDistance), UnitGetPosition(gv_hERO_Raynor), lv_fadeDuration);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_MidDeathCleanup_Init () {
    gt_MidDeathCleanup = TriggerCreate("gt_MidDeathCleanup_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Victory Q
//--------------------------------------------------------------------------------------------------
bool gt_VictoryQ_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerQueueEnter();
    TriggerExecute(gt_VictorySetup, true, true);
    TriggerExecute(gt_VictoryCinematic, true, true);
    TriggerExecute(gt_VictoryCinematicEnd, true, true);
    TriggerExecute(gt_VictoryCleanup, true, true);
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_VictoryQ_Init () {
    gt_VictoryQ = TriggerCreate("gt_VictoryQ_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Victory Setup
//--------------------------------------------------------------------------------------------------
bool gt_VictorySetup_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    libStEx_gf_ClearHintMessage();
    CinematicFade(false, 1.0, c_fadeStyleNormal, ColorWithAlpha(0.00, 0.00, 0.00, 0.00), 0.0, false);
    UISetMode(PlayerGroupAll(), c_uiModeFullscreen, 1.0);
    Wait(1.0, c_timeReal);
    libStEx_gf_CinematicModeTutorial(true, PlayerGroupAll(), 0.0);
    libNtve_gf_GlobalCinematicSetting(true);
    libStEx_gf_TurnCinematicCameraOnOff(gv_pLAYER_01_USER, true);
    GameTimeOfDayPause(true);
    RegionPlayableMapSet(RegionFromId(34));
    libSond_gf_MuteMostSoundChannelsForGameOverState(false);
    SoundChannelMute(PlayerGroupAll(), c_soundCategoryCombat, true);
    UnitGroupLoopBegin(UnitGroup(null, c_playerAny, null, UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32))), 0));
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        if ((libNtve_gf_UnitIsPaused(UnitGroupLoopCurrent()) == false) && (UnitGroupLoopCurrent() != gv_hERO_Raynor)) {
            UnitGroupAdd(gv_cinematicPausedUnits, UnitGroupLoopCurrent());
            libNtve_gf_PauseUnit(UnitGroupLoopCurrent(), true);
        }
        else {
        }
    }
    UnitGroupLoopEnd();
    gv_cinematicHiddenUnits = UnitGroupEmpty();
    gv_cinematicTempUnits = UnitGroupEmpty();
    UnitGroupLoopBegin(gv_cinematicHiddenUnits);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        libNtve_gf_ShowHideUnit(UnitGroupLoopCurrent(), false);
    }
    UnitGroupLoopEnd();
    TriggerEnable(libGame_gt_CoreDiesGameOver, false);
    TriggerEnable(gt__2CPalaceDied, false);
    UnitGroupLoopBegin(UnitGroup(null, c_playerAny, RegionFromId(42), UnitFilter((1 << c_targetFilterBiological), 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0));
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        UnitRemove(UnitGroupLoopCurrent());
    }
    UnitGroupLoopEnd();
    UnitRemove(UnitFromId(918));
    libNtve_gf_SendActorMessageToGameRegion(RegionFromId(38), "Signal CinematicCleanup");
    DialogControlHookupStandard(c_triggerControlTypePanel, "UIContainer/FullscreenUpperContainer/DeathTimerBgLeft");
    DialogControlSetVisible(DialogControlLastCreated(), PlayerGroupAll(), false);
    DialogControlHookupStandard(c_triggerControlTypePanel, "UIContainer/FullscreenUpperContainer/DeathTimerBgRight");
    DialogControlSetVisible(DialogControlLastCreated(), PlayerGroupAll(), false);
    DialogControlHookupStandard(c_triggerControlTypePanel, "UIContainer/FullscreenUpperContainer/Team1DeathTimerBar");
    DialogControlSetVisible(DialogControlLastCreated(), PlayerGroupAll(), false);
    DialogControlHookupStandard(c_triggerControlTypePanel, "UIContainer/FullscreenUpperContainer/Team2DeathTimerBar");
    DialogControlSetVisible(DialogControlLastCreated(), PlayerGroupAll(), false);
    libNtve_gf_ShowHideUnit(gv_hERO_Raynor, false);
    libNtve_gf_ShowHideUnit(gv_hERO_Instructor, false);
    libNtve_gf_ShowHideUnit(gv_hERO_Diablo, false);
    libNtve_gf_ShowHideUnit(gv_hERO_Stitch, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_VictorySetup_Init () {
    gt_VictorySetup = TriggerCreate("gt_VictorySetup_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Victory Cinematic
//--------------------------------------------------------------------------------------------------
bool gt_VictoryCinematic_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unitgroup lv_chaosWaves;
    unitgroup lv_orderWaves;

    // Variable Initialization
    lv_chaosWaves = UnitGroupEmpty();
    lv_orderWaves = UnitGroupEmpty();

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

    gv_cinematicCompleted = false;
    CutsceneCreateNoPosition("Cutscenes\\Tutorial_Cutscene_FinalBattle.StormCutscene", PlayerGroupAll(), false);
    gv_victory_CutScene = CutsceneLastCreated();
    CutscenePlay(CutsceneLastCreated());
    TriggerSkippableBegin(PlayerGroupAll(), 0, null, true, false);
    CinematicFade(true, 1.0, c_fadeStyleNormal, ColorWithAlpha(0.00, 0.00, 0.00, 0.00), 0.0, false);
    WaitForCutsceneToEnd(CutsceneLastCreated());
    gv_cinematicCompleted = true;
    return true;
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_VictoryCinematic_Init () {
    gt_VictoryCinematic = TriggerCreate("gt_VictoryCinematic_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Victory Cinematic End
//--------------------------------------------------------------------------------------------------
bool gt_VictoryCinematicEnd_Func (bool testConds, bool runActions) {
    // Variable Declarations
    fixed lv_fadeDuration;

    // Variable Initialization

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

    if ((gv_cinematicCompleted == false)) {
        lv_fadeDuration = 1.0;
    }
    else {
        lv_fadeDuration = 2.0;
    }
    CinematicFade(false, lv_fadeDuration, c_fadeStyleNormal, ColorWithAlpha(0.00, 0.00, 0.00, 0.00), 0.0, true);
    CutsceneStop(gv_victory_CutScene);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_VictoryCinematicEnd_Init () {
    gt_VictoryCinematicEnd = TriggerCreate("gt_VictoryCinematicEnd_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Victory Cleanup
//--------------------------------------------------------------------------------------------------
bool gt_VictoryCleanup_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TransmissionClearAll();
    PortraitSetVisible(libNtve_gf_CinematicPortrait(2), PlayerGroupAll(), false, false);
    Wait(0.25, c_timeGame);
    SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryMusic, 100.0, 1.0);
    SoundtrackPlay(PlayerGroupAll(), c_soundtrackCategoryMusic, "Storm_Music_Tutorial_Cutscene_End", c_soundtrackCueAny, c_soundtrackIndexAny, true);
    libSond_gf_MuteMostSoundChannelsForGameOverState(true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_VictoryCleanup_Init () {
    gt_VictoryCleanup = TriggerCreate("gt_VictoryCleanup_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger Initialization
//--------------------------------------------------------------------------------------------------
void InitTriggers () {
    gt_Initialization_Init();
    gt_Init01Data_Init();
    gt_Init02Unit_Init();
    gt_Init03UI_Init();
    gt_Init04Environment_Init();
    gt_Init05Ally_Init();
    gt_StormInitializeMap_Init();
    gt_StormHookupGlobalVariables_Init();
    gt_StormHookupLaneData_Init();
    gt_StormHookupJungleCreepData_Init();
    gt_StormHookupTownData_Init();
    gt_StormStartGame_Init();
    gt_DebugStage2Abilities_Init();
    gt_DebugStage3Camera_Init();
    gt_DebugStage4DiabloFight_Init();
    gt_DebugStage5Town_Init();
    gt_DebugStage6Victory_Init();
    gt_DebugTemp_Init();
    gt_AddReferenceCardMove_Init();
    gt_AddReferenceCardAttack_Init();
    gt_AddReferenceCardPenetratingRound_Init();
    gt_AddReferenceCardInspire_Init();
    gt_AddReferenceCardCamera_Init();
    gt__1_RaynorWontDie_Init();
    gt__1AStartGameQ_Init();
    gt__1ABeaconHighlight_Init();
    gt__1ABeaconUnhighlight_Init();
    gt__1AMoveOrderIssued_Init();
    gt__1AMoveButtonSelected_Init();
    gt__1ABeaconReached_Init();
    gt__1ABeaconSound_Init();
    gt__1BAttackSkeleton1Q_Init();
    gt__1BAttackSkeleton1Highlight_Init();
    gt__1BAttackSkeleton1Unhighlight_Init();
    gt__1BAttackSkeleton1Attacked_Init();
    gt__1BAttackSkeleton1Dies_Init();
    gt__1BAttackMoreSkeletonsQ_Init();
    gt__1BMinimapPulse_Init();
    gt__1BAttackMoreSkeletonsAAttacked_Init();
    gt__1BAttackMoreSkeletonsDied_Init();
    gt__1BAttackMoreSkeletonsCAttacked_Init();
    gt__1BAMoveEnemiesApproachedQ_Init();
    gt__1BAMoveAttackOrderIssued_Init();
    gt__1BAMoveHighlight_Init();
    gt__1BAMoveEnemiesAttacked_Init();
    gt__1BAttackSkeletonsWhatAreTheseMonstersQ_Init();
    gt__1BGlobeRun1_Init();
    gt__1BGlobeRun2_Init();
    gt__1BDropGlobe1_Init();
    gt__1BDropGlobe2_Init();
    gt__1BGlobePickedUpQ_Init();
    gt__1CPenRoundPrep_Init();
    gt__1CPenRoundQ_Init();
    gt__1CPenRoundHitQ_Init();
    gt__1CPenRoundTargetingModeOn_Init();
    gt__1CPenRoundTargetingModeOff_Init();
    gt__1CPenRoundCasted_Init();
    gt__1CPenRoundMissedQ_Init();
    gt__1CPenRoundAgainQ_Init();
    gt__1CPenRoundAgainRaynorStop_Init();
    gt__1CPenRoundAgainHitQ_Init();
    gt__1CPenRoundAgainAgainQ_Init();
    gt__1CPenRoundAgainAgainRaynorStop_Init();
    gt__1CPenRoundAgainAgainHitQ_Init();
    gt__1CZombiesInspireQ_Init();
    gt__1CInspireQ_Init();
    gt__1CInspireUseful_Init();
    gt__1CInspireUsedQ_Init();
    gt__1CInspireUseMoreQ_Init();
    gt__1CInspireUsedMore_Init();
    gt__1CInspireUseMoreMoreQ_Init();
    gt__1CInspireUsedMoreMore_Init();
    gt__1CZombieDies_Init();
    gt__1CZombieAllyAttack4_Init();
    gt__1CZombieAllyAttack5_Init();
    gt__1CZombieAttacked_Init();
    gt__1CZombies2Approached_Init();
    gt__1CZombies3Approached_Init();
    gt__1CZombies4Approached_Init();
    gt__1CZombies5Approached_Init();
    gt__1CZombies6Approached_Init();
    gt__1CZombies3DropGlobe_Init();
    gt__1DCameraLockQ_Init();
    gt__1DCameraUnlocked_Init();
    gt__1DCameraMoved_Init();
    gt__1DCameraSpacebarPressed_Init();
    gt__1DCameraArrowLogic_Init();
    gt__1DCameraLocationLogic_Init();
    gt__1DDiabloFightQ_Init();
    gt__1DDiabloPing_Init();
    gt__1DRaynorEnterDiabloBanterQ_Init();
    gt__1DRaynorEnterDiabloRegionChange_Init();
    gt__1DRaynorEnterDiabloArena_Init();
    gt__1DDiabloFightBegin_Init();
    gt__1DDiabloPenetratingRoundUsed_Init();
    gt__1DDiabloAI_Init();
    gt__1DDiabloPenetratingRoundTutorialRaynorDamaged_Init();
    gt__1DDiabloPenetratingRoundTutorialQ_Init();
    gt__1DDiabloPenetratingRoundTutorialUsed_Init();
    gt__1DDiabloWon_Init();
    gt__2ATeleportBaseQ_Init();
    gt__2ATeleportBaseStarted_Init();
    gt__2ATeleportBaseCanceled_Init();
    gt__2ATeleportBaseCompleted_Init();
    gt_MinionSpawnCycleTutorialOrder_Init();
    gt_MinionSpawnCycleTutorialChaos_Init();
    gt_MinionScaling_Init();
    gt__2RemoveEnemyGlobe_Init();
    gt__2BTownStart_Init();
    gt__2BStartMinionSystem_Init();
    gt__2BTowerDanger_Init();
    gt__2BInDangerStrategyBeforeUtherJoins_Init();
    gt__2BMinionStrategyQ_Init();
    gt__2BTowerStrategyQ_Init();
    gt__2BTowerDiesQ_Init();
    gt__2BTowerDamageQ_Init();
    gt__2BTowerTakesDamage_Init();
    gt__2BTowerDamageEscape_Init();
    gt__2BTowerDamageEscapeReticleEffect_Init();
    gt__2BTowerDamageEscapeTransmissionQ_Init();
    gt__2BTowerDamageEscapeWrong_Init();
    gt__2BTowerDamageEscapeMoved_Init();
    gt__2BTowerDamageEscapeReached_Init();
    gt__2BTowerDamageEscapeMore_Init();
    gt__2CFinalBattleStart_Init();
    gt__2CCustomizedHeroDeathTimer_Init();
    gt__2CMountTutorialQ_Init();
    gt__2CMountAway_Init();
    gt__2CMountUsed_Init();
    gt__2CMountNoLongerNeeded_Init();
    gt__2CMountReminder_Init();
    gt__2CMountReminderUsed_Init();
    gt__2CMountReminderNoLongerNeeded_Init();
    gt__2CFortApproached_Init();
    gt__2CFortDestoryedQ_Init();
    gt__2CFortDamage_Init();
    gt__2CFortDamageEscape_Init();
    gt__2CFortDamageEscapeReticleEffect_Init();
    gt__2CFortDamageEscapeTransmissionQ_Init();
    gt__2CFortDamageEscapeWrong_Init();
    gt__2CFortDamageEscapeMoved_Init();
    gt__2CFortDamageEscapeReached_Init();
    gt__2CFortTakesDamage_Init();
    gt__2CUtherJoins_Init();
    gt__2CPalaceDamage_Init();
    gt__2CPalaceDamageEscape_Init();
    gt__2CPalaceDamageEscapeReticleEffect_Init();
    gt__2CPalaceDamageEscapeTransmissionQ_Init();
    gt__2CPalaceDamageEscapeWrong_Init();
    gt__2CPalaceDamageEscapeMoved_Init();
    gt__2CPalaceDamageEscapeReached_Init();
    gt__2CPalaceTakesDamage_Init();
    gt__2CPalaceDied_Init();
    gt__2CTakingDamageFromMinion_Init();
    gt__2CTakingDamageFromMinionTransmission_Init();
    gt__2CUseAbilitiesStartTimer_Init();
    gt__2CUseAbilitiesTimerExpires_Init();
    gt__2CUseAbilitiesUsed_Init();
    gt_ObjectiveMoveToBeaconCreate_Init();
    gt_ObjectiveMoveToBeaconComplete_Init();
    gt_ObjectiveKilltheUndeadCreate_Init();
    gt_ObjectiveKilltheUndeadComplete_Init();
    gt_ObjectiveKillMoreUndeadCreate_Init();
    gt_ObjectiveKillMoreUndeadUpdate_Init();
    gt_ObjectiveKillMoreUndeadComplete_Init();
    gt_ObjectiveKillZombiesCreate_Init();
    gt_ObjectiveKillZombiesUpdate_Init();
    gt_ObjectiveKillZombiesComplete_Init();
    gt_ObjectiveFindDiabloCreate_Init();
    gt_ObjectiveFindDiabloComplete_Init();
    gt_ObjectiveKillDiabloCreate_Init();
    gt_ObjectiveKillDiabloComplete_Init();
    gt_ObjectiveBacktoBaseCreate_Init();
    gt_ObjectiveBacktoBaseComplete_Init();
    gt_ObjectiveMountUpCreate_Init();
    gt_ObjectiveMountUpComplete_Init();
    gt_ObjectiveKillEnemyTowersCreate_Init();
    gt_ObjectiveKillEnemyTowersUpdate_Init();
    gt_ObjectiveKillEnemyTowersComplete_Init();
    gt_ObjectiveKillEnemyFortCreate_Init();
    gt_ObjectiveKillEnemyFortComplete_Init();
    gt_ObjectiveKillEnemyPalaceCreate_Init();
    gt_ObjectiveKillEnemyPalaceComplete_Init();
    gt_ObjectiveMovetoFrontLineCreate_Init();
    gt_ObjectiveMovetoFrontLineComplete_Init();
    gt_IntroQ_Init();
    gt_IntroSetup_Init();
    gt_IntroCinematic_Init();
    gt_IntroCinematicEnd_Init();
    gt_IntroCleanup_Init();
    gt_IntroReticleEffect_Init();
    gt_MidSkeletonAttackQ_Init();
    gt_MidSkeletonAttackSetup_Init();
    gt_MidSkeletonAttackCinematic_Init();
    gt_MidSkeletonAttackCinematicEnd_Init();
    gt_MidSkeletonAttackCleanup_Init();
    gt_MidSkeletonAttackUtherMove_Init();
    gt_MidAbilityQ_Init();
    gt_MidAbilitySetup_Init();
    gt_MidAbilityCinematic_Init();
    gt_MidAbilityCinematicEnd_Init();
    gt_MidAbilityCleanup_Init();
    gt_MidGarrisonQ_Init();
    gt_MidGarrisonSetup_Init();
    gt_MidGarrisonCinematic_Init();
    gt_MidGarrisonCinematicEnd_Init();
    gt_MidGarrisonCleanup_Init();
    gt_MidGarrisonCinematicSpawnChaosWave_Init();
    gt_MidGarrisonCinematicSpawnOrderWave_Init();
    gt_MidGarrisonCinematicMinionCamera_Init();
    gt_MidTowerDangerQ_Init();
    gt_MidTowerDangerSetup_Init();
    gt_MidTowerDangerCinematic_Init();
    gt_MidTowerDangerCinematicEnd_Init();
    gt_MidTowerDangerCleanup_Init();
    gt_MidDeathQ_Init();
    gt_MidDeathSetup_Init();
    gt_MidDeathCinematic_Init();
    gt_MidDeathCinematicEnd_Init();
    gt_MidDeathCleanup_Init();
    gt_VictoryQ_Init();
    gt_VictorySetup_Init();
    gt_VictoryCinematic_Init();
    gt_VictoryCinematicEnd_Init();
    gt_VictoryCleanup_Init();
}

//--------------------------------------------------------------------------------------------------
// Map Initialization
//--------------------------------------------------------------------------------------------------
void InitMap () {
    InitLibs();
    InitGlobals();
    InitCustomScript();
    InitTriggers();
}
