//==================================================================================================
// 
// Generated Map Script
// 
// Name:   Burning Tide
// Author: Blizzard Entertainment
// 
//==================================================================================================
include "TriggerLibs/NativeLib"
include "TriggerLibs/LibertyLib"

//--------------------------------------------------------------------------------------------------
// Library Initialization
//--------------------------------------------------------------------------------------------------
void InitLibs () {
    libNtve_InitLib();
    libLbty_InitLib();
}

//--------------------------------------------------------------------------------------------------
// Global Variables
//--------------------------------------------------------------------------------------------------
timer gv_lavaTimer;
timer gv_warning01Timer;
timer gv_warning02Timer;
fixed gv_lavaInterval;
bool gv_lowGroundIsSafe;
int gv_lavaDeathsBoard;
int gv_lavaDeaths;
int gv_lavaSurgeCounter;
int gv_tempLavaDeaths;
int gv_randomPickedRegion;
region[25] gv_mineralRegions;
int gv_maxMineralRegions;
int gv_mINERALS_NEEDED;
int gv_minerals_Needed_Board;
int gv_northTeamMinerals;
int gv_southTeamMinerals;
playergroup gv_northTeam;
playergroup gv_southTeam;
text gv_textInitialWarning;

void InitGlobals () {
    int init_i;

    gv_lavaTimer = TimerCreate();
    gv_warning01Timer = TimerCreate();
    gv_warning02Timer = TimerCreate();
    gv_lavaInterval = 240.0;
    gv_lowGroundIsSafe = true;
    gv_lavaDeathsBoard = c_boardNone;
    gv_lavaDeaths = 0;
    gv_lavaSurgeCounter = 0;
    gv_tempLavaDeaths = 0;
    gv_randomPickedRegion = 0;
    init_i = 0;
    while (init_i <= 24) {
        gv_mineralRegions[init_i] = null;
        init_i = init_i + 1;
    }
    gv_maxMineralRegions = 0;
    gv_mINERALS_NEEDED = 0;
    gv_minerals_Needed_Board = c_boardNone;
    gv_northTeamMinerals = 0;
    gv_southTeamMinerals = 0;
    gv_northTeam = PlayerGroupEmpty();
    gv_southTeam = PlayerGroupEmpty();
    gv_textInitialWarning = StringExternal("Param/Value/DAF9D2DE");
}

//--------------------------------------------------------------------------------------------------
// Global Function Declarations
//--------------------------------------------------------------------------------------------------
void gf_SpawnRandomMineralShard (region lp_chosenRegion);

//--------------------------------------------------------------------------------------------------
// Trigger Variables
//--------------------------------------------------------------------------------------------------
trigger gt_MeleeInitialization;
trigger gt_InitHelpPanel;
trigger gt_LavaSurgeMusic;
trigger gt_CameraShakeWeak;
trigger gt_CameraShakeStrong;
trigger gt_CameraShakeDuringLava;
trigger gt_CreateLavaDeathsLeaderboard;
trigger gt_UpdateLavaDeathsBoard;
trigger gt_PlayLavaDeathSound;
trigger gt_LavaTurnsON;
trigger gt_LavaTurnsOFF;
trigger gt_LavaDamage;
trigger gt_TransmissionLavaWarning01Q;
trigger gt_TransmissionLavaWarning02Q;
trigger gt_TransmissionItsSafeQ;
trigger gt_CreateMineralCountBoard;
trigger gt_UpdateMineralCountBoard;
trigger gt_InitLavaMineralRegions;
trigger gt_SpawnRandomMinerals;
trigger gt_WarningNTeamCloseToVictory;
trigger gt_WarningSTeamCloseToVictory;
trigger gt_ResourcePickups;
trigger gt_TipLavaMechanic;
trigger gt_TipMineralPickups;

//--------------------------------------------------------------------------------------------------
// Custom Script: AI Basic Custom Logic
//--------------------------------------------------------------------------------------------------
//==================================================================================================
//  Custom AI Logic for Burning Tide (stay at home and gather resources).
//--------------------------------------------------------------------------------------------------
    
//--------------------------------------------------------------------------------------------------
//  AINewUnitDefaultBT
//--------------------------------------------------------------------------------------------------
void AINewUnitDefaultBT (int player, unit u) {
    wave w = AIWaveGet(player, c_waveMain);
    AIMergeUnit(player, u, w);
}
    
//--------------------------------------------------------------------------------------------------
//  AIWaveThinkDefaultBT
//--------------------------------------------------------------------------------------------------
void AIWaveThinkDefaultBT (int player, wave w, int type) {
    // all waves should just guard home on this map
    int state = AIWaveState(w);
    if (state != c_waveStateDefend) {
       AIWaveSetType(w, c_waveStateDefend, AIWaveTargetMeleeDefend(player));
    }
}
    
//--------------------------------------------------------------------------------------------------
//  AINeedsDefendingBT
//--------------------------------------------------------------------------------------------------
bool AINeedsDefendingBT (int player) {
    return false;
}
    
//--------------------------------------------------------------------------------------------------
//  GiveRemoteHarvestOrderBT
//--------------------------------------------------------------------------------------------------
void GiveRemoteHarvestOrderBT (int player, unit curUnit) {
    int mineralCount;    
    point unitPos;
    point minPos;
    fixed curDist;
    fixed closestDist = 250;
    unit closestMin;
    unit curMin;
    unit bestDropOff;
    unitgroup minerals;
    unitgroup dropOffs;
    abilcmd harvestAbilDropOff;
    abilcmd harvestAbilGather;
    string curType = UnitGetType(curUnit);
    
    if (curType == c_ZU_Drone) {
        harvestAbilGather= AbilityCommand("DroneHarvest", 0);
        harvestAbilDropOff= AbilityCommand("DroneHarvest", 1);
    }
    else if (curType == c_PU_Probe) {
        harvestAbilGather= AbilityCommand("ProbeHarvest", 0);
        harvestAbilDropOff= AbilityCommand("ProbeHarvest", 1);
    }
    else if (curType == c_TU_SCV) {
        harvestAbilGather= AbilityCommand("SCVHarvest", 0);
        harvestAbilDropOff= AbilityCommand("SCVHarvest", 1);
    }
    else if (curType == "MULE") {
        harvestAbilGather= AbilityCommand("MULEGather", 0);
        harvestAbilDropOff= AbilityCommand("MULEGather", 1);
    }
    else {
        // unknown worker type?
        return;
    }
    
    unitPos = AIGetGatherLocation(player, c_townMain); //UnitGetPosition(curUnit);
    minerals = UnitGroup("RichMineralField", 0, null, null, c_noMaxCount);
    mineralCount = UnitGroupCount(minerals, c_unitCountAll);
    while (mineralCount > 0) {
        curMin = UnitGroupUnit(minerals, mineralCount );
        minPos = UnitGetPosition(curMin);
        curDist = DistanceBetweenPoints(unitPos, minPos);
        if (curDist < closestDist ) {
            if (PointPathingIsConnected(unitPos, minPos)) {
                closestDist = curDist;
                closestMin = curMin;
            }
        }
        mineralCount = mineralCount - 1;
    }
    
    if (closestDist < 250) {
        // found a best mineral, try to harvest it
        AISetUnitScriptControlled(curUnit,true);
        UnitIssueOrder(curUnit,Order(AbilityCommand("stop", 0)),c_orderQueueReplace);
        // go to the closest dropoff first in case we were holding something
        dropOffs = AIGetBuildingGroup(player, c_buildingTypeTownHall);
        bestDropOff = AIGetClosestUnit(curUnit, dropOffs, true);
        UnitIssueOrder(curUnit,Order(harvestAbilDropOff),c_orderQueueReplace);
        UnitIssueOrder(curUnit,OrderTargetingUnit(harvestAbilGather,closestMin),c_orderQueueAddToEnd);
    }
}
    
//--------------------------------------------------------------------------------------------------
//  AIManageRemoteMiningAndFleeLavaBT 
//--------------------------------------------------------------------------------------------------
void AIManageRemoteMiningAndFleeLavaBT (int player) {
    int desiredNormalWorkers;
    int currentNormalWorkers;
    int unitCount;
    unitgroup playerUnits;
    unit curUnit;
    unit normalWorker = c_nullUnit;
    unit scriptWorker = c_nullUnit;
    bool isLavaDanger;
    bool isInDanger;
    string curUnitType;
    order ord;
    
    isLavaDanger = (TimerGetRemaining(gv_lavaTimer) < 20.0);
    desiredNormalWorkers = 3 * (AIGetHarvestableGasNumSpots(player, c_townMain) + AIGetMineralNumSpots(player, c_townMain));
    currentNormalWorkers = 0;
    
    playerUnits = UnitGroup(null, player, null, null, c_noMaxCount);
    unitCount= UnitGroupCount(playerUnits , c_unitCountAll);
    while (unitCount > 0) {
        curUnit = UnitGroupUnit(playerUnits , unitCount);
        curUnitType = UnitGetType(curUnit);
        
        isInDanger = false;
        if (isLavaDanger) {
            if (WorldHeight(c_heightMapGround, UnitGetPosition(curUnit)) <= 9.7) {
                // unit is in danger, tell it to move to high ground
                isInDanger = true;
                
                AISetUnitScriptControlled(curUnit,true);
                UnitIssueOrder( curUnit, OrderTargetingPoint(AbilityCommand("move", 0),
                                AIGetGatherDefLocation(player, c_townMain)), c_orderQueueReplace);
            }
        }
        
        if (UnitTypeTestFlag(curUnitType, c_unitFlagWorker)) {
            // logic for workers
            if (!AIIsScriptControlled(curUnit)) {
                currentNormalWorkers += 1;
                if (!UnitTestState(curUnit, c_unitStateHidden)) {
                    normalWorker = curUnit;
                }
            }
            else {
                // script controlled worker logic
                scriptWorker = curUnit;
                if (isLavaDanger) {
                    // flee from lava and wait
                    UnitIssueOrder( curUnit, OrderTargetingPoint(AbilityCommand("move", 0),
                                AIGetGatherDefLocation(player, c_townMain)), c_orderQueueReplace);
                }
                else {
                    if (!UnitTestState(curUnit, c_unitStateHidden)) {
                        // no lava danger, give it a harvest order if idle
                        if (UnitOrder(curUnit, 0) == null) {
                            GiveRemoteHarvestOrderBT(player, curUnit);
                        }
                    }
                }
            }
        }
        else {
            if (!isInDanger) {
                if (AIIsScriptControlled(curUnit)) {              
                    AISetUnitScriptControlled(curUnit,false);
                }
            }
        }
        
        unitCount = unitCount- 1;
    }
    if (currentNormalWorkers > desiredNormalWorkers) {
        if (!isLavaDanger && normalWorker != c_nullUnit) {    
            // I have excess normal harvesting peons start one remote mining
            GiveRemoteHarvestOrderBT(player, normalWorker);
        }
    }
    else if (currentNormalWorkers < desiredNormalWorkers) {
        if (scriptWorker != c_nullUnit) {
            // I have too few normal harvesting peons, return some to normal control
            UnitIssueOrder(scriptWorker, OrderTargetingPoint(AbilityCommand("move", 0),
                                    AIGetGatherDefLocation(player, c_townMain)), c_orderQueueReplace);
            AISetUnitScriptControlled(scriptWorker, false);
        }
    }
}
    
//--------------------------------------------------------------------------------------------------
//  Default startup routine
//--------------------------------------------------------------------------------------------------
void AIMeleeStartBT (int player) {
    point targDPoint;
    point targOPoint;
    wavetarget targD;
    wavetarget targO;
    
    //TriggerDebugOutput(
    //    1,
    //    StringToText("[") +
    //    PlayerColorName(PlayerGetColorIndex(player, false)) +
    //    StringToText("] ") +
    //    StringToText("AI Started with BT"),
    //    true
    //);
    
    AIStart(player, false, DifficultyAPM(c_skirVeryHard));
    
    AISetDifficulty(player, c_diffNormalVision, true);
    AISetDifficulty(player, c_diffLimitAPM,     true);
    
    AISetDifficulty(player, c_diffSpotChangelings,   true);
    AISetDifficulty(player, c_diffWaveAvoidDanger,   true);
    AISetDifficulty(player, c_diffFleeDamage,        true);
    AISetDifficulty(player, c_diffEarlyDefenseScout, true);
    AISetDifficulty(player, c_diffUseExtraScouts,    true);
    AISetDifficulty(player, c_diffHoldAtIdleChokes,  true);
    AISetDifficulty(player, c_diffPressForward,      true);
    AISetDifficulty(player, c_diffFleeWorkers,       true);
    AISetDifficulty(player, c_diffFleeDanger,        true);
    
    AISetDifficulty(player, c_diffRepairDamage, true);
    AISetDifficulty(player, c_diffOptimizeGas, true);
    AISetDifficulty(player, c_diffDefendWithPeons, true);
    AISetDifficulty(player, c_diffEnableDangerMap, true);
    AISetDifficulty(player, c_diffNormalTargetPrio, true);
    AISetDifficulty(player, c_diffAllowResourceReq, true);
    AISetDifficulty(player, c_diffUseRetreatLogic, true);
    
    AISetDifficulty(player, c_diffAutoLoadBunkers, false);
    AISetDifficulty(player, c_diffEarlyGameRepair, false);
    
    AISetFlag(player, e_flagsRunScared, true);
    
    AISetFlag(player, e_flagsLateScout, false);
    AISetFlag(player, e_flagsClearObs, false);
    
    AIDeclareTown(player, c_townOne, PlayerStartLocation(player));
    AISetMainTown(player, c_townOne);
    AIHarvest(player, c_townOne);
    AISetAllStates(player, 1);
    
    targDPoint = AIWaveTargetGatherDPoint(player, c_townMain);
    targOPoint = AIWaveTargetGatherOPoint(player, c_townMain);
    targD = AIWaveTargetGatherD(player, c_townMain);
    targO = AIWaveTargetGatherO(player, c_townMain);
    
    AIWaveSet(player, c_waveMain,       AIWaveCreate(AIWaveInfoCreate(), player, targOPoint));
    AIWaveSet(player, c_waveAttack,     AIWaveCreate(AIWaveInfoCreate(), player, targOPoint));
    AIWaveSet(player, c_waveDivert1,    AIWaveCreate(AIWaveInfoCreate(), player, targOPoint));
    AIWaveSet(player, c_waveDivert2,    AIWaveCreate(AIWaveInfoCreate(), player, targOPoint));
    AIWaveSet(player, c_waveClearObs,   AIWaveCreate(AIWaveInfoCreate(), player, targOPoint));
    AIWaveSet(player, c_waveHome,       AIWaveCreate(AIWaveInfoCreate(), player, targDPoint));
    AIWaveSet(player, c_waveDefend,     AIWaveCreate(AIWaveInfoCreate(), player, targDPoint));
    
    AIWaveSetType(AIWaveGet(player, c_waveMain),     c_waveStateIdle, targO);
    AIWaveSetType(AIWaveGet(player, c_waveAttack),   c_waveStateIdle, targO);
    AIWaveSetType(AIWaveGet(player, c_waveDivert1),  c_waveStateIdle, targO);
    AIWaveSetType(AIWaveGet(player, c_waveDivert2),  c_waveStateIdle, targO);
    AIWaveSetType(AIWaveGet(player, c_waveClearObs), c_waveStateIdle, targO);
    AIWaveSetType(AIWaveGet(player, c_waveHome),     c_waveStateIdle, targD);
    AIWaveSetType(AIWaveGet(player, c_waveDefend),   c_waveStateIdle, targD);
    
    AISetMaxBestAttackersLimit(player, AIMeleeDiffSelect(player, 1, 2, 4, 8, 16, 32));
    
    AITransportIgnore(player, "VikingAssault");
    AITransportSetPanic(player, 0.6);
    AITransportSetReturn(player, targDPoint);
    
    AISetNumScouts(player, 0);
    
    AISpecifiedMakers();
    AISpecifiedHealers(player);
    AIAddDetectionDangerUnits(player);
    AISetNukeConstants(player);
    
    // - AISetDefaultCombatFlags(player, true);
    AICombatDiffFlagCatSpecialHighPrio     (player, c_combatFlagEnable);
    AICombatDiffFlagCatSplashHighPrio      (player, c_combatFlagEnable);
    AICombatDiffFlagCatTimedLowPrio        (player, c_combatFlagEnable);
    AICombatDiffFlagCatWorkersNormalPrio   (player, c_combatFlagEnable);
    AICombatDiffFlagCatSortBuildingsPrio   (player, c_combatFlagEnable);
    AICombatDiffFlagTieBreakHealers        (player, c_combatFlagEnable);
    AICombatDiffFlagTieBreakBonusDamage    (player, c_combatFlagEnable);
    AICombatDiffFlagTieBreakLowHP          (player, c_combatFlagEnable);
    AICombatDiffFlagTieBreakInjured        (player, c_combatFlagEnable);
    AICombatDiffFlagTieBreakDetector       (player, c_combatFlagEnable);
    AICombatDiffFlagTieBreakRange          (player, c_combatFlagEnable);
}
    

//--------------------------------------------------------------------------------------------------
// Custom Script: Protoss Custom Logic
//--------------------------------------------------------------------------------------------------
//==================================================================================================
//  Custom Protoss AI for Burning Tide
//==================================================================================================
    
//--------------------------------------------------------------------------------------------------
//  AINewUnitProtBT
//--------------------------------------------------------------------------------------------------
void AINewUnitProtBT (int player, unit u) {
    string type = UnitGetType(u);
    
    // ignored units
    //
    if (UnitTypeTestAttribute(type, c_unitAttributeStructure)) {
        return;
    }
    if (UnitTypeTestFlag(type, c_unitFlagWorker)) {
        return;
    }
    
    AINewUnitDefaultBT(player, u);
}
    
//--------------------------------------------------------------------------------------------------
//  AIGetScoutProtBT
//--------------------------------------------------------------------------------------------------
unit AIGetScoutProtBT (int player, int index, unit prev, bool allowWorkers) {   
    return c_nullUnit;
}
    
//--------------------------------------------------------------------------------------------------
//  AIEarlyDefScoutProtBT
//--------------------------------------------------------------------------------------------------
unit AIEarlyDefScoutProtBT (int player, unit prev, bool allowWorkers) {
    return c_nullUnit;
}
    
//--------------------------------------------------------------------------------------------------
//  AIWaveThinkProtBT
//--------------------------------------------------------------------------------------------------
void AIWaveThinkProtBT (int player, wave w, int type) {
    AIWaveThinkDefaultBT(player, w, type);
}
    
//--------------------------------------------------------------------------------------------------
//  ProtInitBT
//--------------------------------------------------------------------------------------------------
static void ProtInitBT (int player) {
    int state;
    
    AISetFlag(player, e_flagsEarlyDefScout, false);
    AISetPowerBuilding(player, c_PB_Pylon);
    
    AISetMainState(player, e_mainState_OpenGnd0, e_mainSubState_Unset);
}
    
//--------------------------------------------------------------------------------------------------
//  AIMeleeProtBT
//--------------------------------------------------------------------------------------------------
void AIMeleeProtBT (int player) {
    int mainState = AIState(player, e_mainState);
    if (mainState == e_mainState_Init) { 
        ProtInitBT(player);
    }
    
    // full game set stock for burning tide: 
    //   it basically makes peons and harvests with a token defense
    //   i.e. pure win by minerals (greed) strategy
    AIClearStock(player);
    
    AISetStock( player, 1, c_PB_Nexus );
    AISetStock( player, 9, c_PU_Probe );
    AISetStock( player, 1, c_PB_Pylon );
    AISetStock( player, 13, c_PU_Probe );
    AISetStock( player, 1, c_PB_Gateway );
    AISetStock( player, 14, c_PU_Probe );
    AISetStock( player, 1, c_PB_Assimilator );
    AISetStock( player, 16, c_PU_Probe );
    AISetStock( player, 2, c_PB_Pylon );
    AISetStock( player, 18, c_PU_Probe );
    AISetStock( player, 1, c_PB_CyberneticsCore );
    AISetStock( player, 1, c_PU_Zealot );
    AISetStock( player, 20, c_PU_Probe );
    AISetStock( player, 2, c_PU_Zealot );
    AISetStock( player, 1, c_PR_WarpGateResearch );
    AISetStock( player, 1, c_PU_Stalker );
    AISetStockEx(player, c_townMain, 3, c_PB_Pylon, c_makeExpanPower, 0);
    AISetStock( player, 2, c_PB_Gateway );
    AISetStock( player, 4, c_PU_Stalker );
    AISetStockEx(player, c_townMain, 4, c_PB_Pylon, c_makeExpanPower, 0);
    AISetStock( player, 8, c_PU_Stalker );
    AISetStock( player, 2, c_PB_PhotonCannon );
    
    // just in case, default econ
    AIDefaultEconomy(player, c_PB_Nexus, c_PB_Assimilator, c_PB_Pylon, c_PU_Probe, 40, c_stockAlways);
    
    AIEnableStock(player);
    
    AIManageRemoteMiningAndFleeLavaBT (player);
}
    

//--------------------------------------------------------------------------------------------------
// Custom Script: Terran Custom Logic
//--------------------------------------------------------------------------------------------------
//==================================================================================================
//  Custom Terran AI for Burning Tide
//==================================================================================================
    
//--------------------------------------------------------------------------------------------------
//  AINewUnitTerrBT
//--------------------------------------------------------------------------------------------------
void AINewUnitTerrBT (int player, unit u) {
    string type = UnitGetType(u);
    
    // ignored units
    //
    if (UnitTypeTestAttribute(type, c_unitAttributeStructure)) {
        return;
    }
    if (UnitTypeTestFlag(type, c_unitFlagWorker)) {
        return;
    }
    
    AINewUnitDefaultBT(player, u);
}
    
//--------------------------------------------------------------------------------------------------
//  AIGetScoutTerrBT
//--------------------------------------------------------------------------------------------------
unit AIGetScoutTerrBT (int player, int index, unit prev, bool allowWorkers) {   
    return c_nullUnit;
}
    
//--------------------------------------------------------------------------------------------------
//  AIEarlyDefScoutTerrBT
//--------------------------------------------------------------------------------------------------
unit AIEarlyDefScoutTerrBT (int player, unit prev, bool allowWorkers) {
    return c_nullUnit;
}
    
//--------------------------------------------------------------------------------------------------
//  AIWaveThinkTerrBT
//--------------------------------------------------------------------------------------------------
void AIWaveThinkTerrBT (int player, wave w, int type) {
    AIWaveThinkDefaultBT(player, w, type);
}
    
//--------------------------------------------------------------------------------------------------
//  TerrInitBT
//--------------------------------------------------------------------------------------------------
static void TerrInitBT (int player) {
    int state;
    
    AISetFlag(player, e_flagsEarlyDefScout, false);
    AITechCountFixupEither(player, c_TB_CommandCenter, c_TB_OrbitalCommand, c_TB_PlanetaryFortress);
    
    AISetMainState(player, e_mainState_OpenGnd0, e_mainSubState_Unset);
}
    
//--------------------------------------------------------------------------------------------------
//  AIMeleeTerrBT
//--------------------------------------------------------------------------------------------------
void AIMeleeTerrBT (int player) {
    int mainState = AIState(player, e_mainState);
    if (mainState == e_mainState_Init) { 
        TerrInitBT(player);
    }
    
    // full game set stock for burning tide: 
    //   it basically makes peons and harvests with a token defense
    //   i.e. pure win by minerals (greed) strategy
    AIClearStock(player);
    
    AISetStock( player, 1, c_TB_CommandCenter_Alias );
    AISetStock( player, 10, c_TU_SCV );
    AISetStock( player, 1, c_TB_SupplyDepot );
    AISetStock( player, 12, c_TU_SCV );
    AISetStock( player, 1, c_TB_Barracks );
    AISetStock( player, 16, c_TU_SCV );
    AISetStock( player, 1, c_TB_OrbitalCommand );
    AISetStock( player, 2, c_TU_Marine );
    AISetStock( player, 2, c_TB_SupplyDepot );
    AISetStock( player, 1, c_TB_Refinery );
    AISetStock( player, 18, c_TU_SCV );
    AISetStock( player, 4, c_TU_Marine );
    AISetStock( player, 20, c_TU_SCV );
    AISetStock( player, 2, c_TB_Barracks );
    AISetStock( player, 3, c_TB_SupplyDepot );
    AISetStock( player, 10, c_TU_Marine );
    AISetStock( player, 1, c_TR_MarineShield);
    AISetStock( player, 15, c_TU_Marine );
    AISetStock( player, 2, c_TB_MissileTurret);
    AISetStock( player, 1, c_TR_MissileTurretRange);
    AISetStock( player, 1, c_TR_MarineStimPack );
    
    // just in case, default econ
    AIDefaultEconomy(player, c_TB_CommandCenter_Alias, c_TB_Refinery, c_TB_SupplyDepot, c_TU_SCV, 40, c_stockAlways);
    
    AIEnableStock(player);
    
    AIManageRemoteMiningAndFleeLavaBT (player);
}
    

//--------------------------------------------------------------------------------------------------
// Custom Script: Zerg Custom Logic
//--------------------------------------------------------------------------------------------------
//==================================================================================================
//  Custom Zerg AI for Burning Tide
//==================================================================================================
    
//--------------------------------------------------------------------------------------------------
//  AINewUnitZergBT
//--------------------------------------------------------------------------------------------------
void AINewUnitZergBT (int player, unit u) {
    string type = UnitGetType(u);
    
    // ignored units
    //
    if (type == c_ZU_Larva || 
        type == c_ZU_Broodling ||
        type == c_ZU_Mantaling) {
        return;
    }
    if (UnitTypeTestAttribute(type, c_unitAttributeStructure)) {
        return;
    }
    if (UnitTypeTestFlag(type, c_unitFlagWorker)) {
        return;
    }
    
    if (type == c_ZU_Overlord || type == c_ZU_OverlordCocoon ) {
        AIWaveAddUnitPriority(AIWaveGet(player, c_waveHome), u, c_prioWavePeon);
        return;
    }
    if (type == c_ZB_SpineCrawler || type == c_ZB_SporeCrawler) {
        AIWaveAddUnitPriority(AIWaveGet(player, c_waveHome), u, c_prioWavePeon);
        return;
    }
    if (type == c_ZU_Queen) {
        AIWaveAddUnitPriority(AIWaveGet(player, c_waveHome), u, c_prioWavePeon);
        return;
    }
    
    AINewUnitDefaultBT(player, u);
}
    
//--------------------------------------------------------------------------------------------------
//  AIGetScoutZergBT
//--------------------------------------------------------------------------------------------------
unit AIGetScoutZergBT (int player, int index, unit prev, bool allowWorkers) {   
    return c_nullUnit;
}
    
//--------------------------------------------------------------------------------------------------
//  AIEarlyDefScoutZergBT
//--------------------------------------------------------------------------------------------------
unit AIEarlyDefScoutZergBT (int player, unit prev, bool allowWorkers) {
    return c_nullUnit;
}
    
//--------------------------------------------------------------------------------------------------
//  AIWaveThinkZergBT
//--------------------------------------------------------------------------------------------------
void AIWaveThinkZergBT (int player, wave w, int type) {
    AIWaveThinkDefaultBT(player, w, type);
}
    
//--------------------------------------------------------------------------------------------------
//  Zerg InitBT
//--------------------------------------------------------------------------------------------------
static void ZergInitBT (int player) {
    int state;
    
    AISetFlag(player, e_flagsEarlyDefScout, false);
    AIReqCountAsBuiltObject(player, c_ZU_Larva);
    AITechCountFixupSingle(player, c_ZB_Spire, c_ZB_GreaterSpire);
    AITechCountFixupInOrder(player, c_ZB_Hatchery, c_ZB_Lair, c_ZB_Hive);
    AISetCreepBuilding(player, c_ZB_CreepTumor, "ZergBuildingNotOnCreep");
    
    AISetMainState(player, e_mainState_OpenGnd0, e_mainSubState_Unset);
}
    
//--------------------------------------------------------------------------------------------------
//  AIMeleeZergBT
//--------------------------------------------------------------------------------------------------
void AIMeleeZergBT (int player) {
    int mainState = AIState(player, e_mainState);
    if (mainState == e_mainState_Init) { 
        ZergInitBT(player);
    }
    
    // full game set stock for burning tide: 
    //   it basically makes peons and harvests with a token defense
    //   i.e. pure win by minerals (greed) strategy
    AIClearStock(player);
    
    AISetStock( player, 1, c_ZB_Hatchery_Alias );
    AISetStock( player, 2, c_ZU_Drone );
    AISetStock( player, 1, c_ZU_Overlord );
    AISetStock( player, 10, c_ZU_Drone );
    AISetStock( player, 2, c_ZU_Overlord );
    AISetStock( player, 13, c_ZU_Drone );
    AISetStock( player, 1, c_ZB_SpawningPool );
    AISetStock( player, 16, c_ZU_Drone );
    AISetStock( player, 1, c_ZU_Queen );
    AISetStock( player, 1, c_ZB_Extractor );
    AISetStock( player, 3, c_ZU_Overlord );
    AISetStock( player, 8, c_ZU_Zergling );
    AISetStock( player, 20, c_ZU_Drone );
    AISetStock( player, 1, c_ZB_Lair_Alias ); 
    AISetStock( player, 4, c_ZU_Overlord );
    AISetStock( player, 1, c_ZB_HydraliskDen );  
    AISetStock( player, 4, c_ZU_Hydralisk );
    AISetStock( player, 1, c_ZR_HydraliskRange );
    AISetStock( player, 2, c_ZB_SporeCrawler );
    AISetStock( player, 1, c_ZU_Overseer );
    AISetStock( player, 5, c_ZU_Overlord_Alias );
    AISetStock( player, 8, c_ZU_Hydralisk );
    
    // just in case, default econ
    AIDefaultEconomy(player, c_ZB_Hatchery_Alias, c_ZB_Extractor, c_ZU_Overlord_Alias, c_ZU_Drone, 40, c_stockAlways);
    
    AIEnableStock(player);
    
    AIManageRemoteMiningAndFleeLavaBT (player);
}
    

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

//--------------------------------------------------------------------------------------------------
// Global Functions
//--------------------------------------------------------------------------------------------------
void gf_SpawnRandomMineralShard (region lp_chosenRegion) {
    // Implementation
    UnitCreate(1, "NaturalMinerals", 0, 0, RegionRandomPoint(lp_chosenRegion), libNtve_gf_RandomAngle());
}

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

    MeleeInitResources();
    MeleeInitUnits();
    MeleeInitAI();
    MeleeInitOptions();
    gv_lowGroundIsSafe = true;
    gv_mINERALS_NEEDED = 15000;
    IntLoopBegin(1, 6);
    while (!IntLoopDone()) {
        if (((PlayerType(IntLoopCurrent()) == c_playerTypeUser) || (PlayerType(IntLoopCurrent()) == c_playerTypeComputer))) {
            if (((PlayerStartLocation(IntLoopCurrent()) == PointFromId(49)) || (PlayerStartLocation(IntLoopCurrent()) == PointFromId(50)) || (PlayerStartLocation(IntLoopCurrent()) == PointFromId(51)))) {
                PlayerGroupAdd(gv_northTeam, IntLoopCurrent());
            }
            else {
            }
            if (((PlayerStartLocation(IntLoopCurrent()) == PointFromId(112)) || (PlayerStartLocation(IntLoopCurrent()) == PointFromId(115)) || (PlayerStartLocation(IntLoopCurrent()) == PointFromId(116)))) {
                PlayerGroupAdd(gv_southTeam, IntLoopCurrent());
            }
            else {
            }
        }
        else {
        }
        IntLoopStep();
    }
    IntLoopEnd();
    TimerStart(gv_warning01Timer, (60.0 - 30.0), false, c_timeGame);
    TimerStart(gv_warning02Timer, (60.0 - 10.0), false, c_timeGame);
    TimerStart(gv_lavaTimer, 60.0, false, c_timeGame);
    libNtve_gf_PlayAnimationOnDoodadsInRegion(RegionEntireMap(), "CharAshWeather", c_animNameDefault, "Death", c_animFlagPlayForever, c_animTimeDefault);
    TriggerExecute(gt_InitHelpPanel, true, false);
    TriggerExecute(gt_CreateMineralCountBoard, true, false);
    TriggerExecute(gt_CreateLavaDeathsLeaderboard, true, false);
    Wait(30.0, c_timeGame);
    TriggerExecute(gt_TipLavaMechanic, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_MeleeInitialization_Init () {
    gt_MeleeInitialization = TriggerCreate("gt_MeleeInitialization_Func");
    TriggerAddEventMapInit(gt_MeleeInitialization);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Init Help Panel
//--------------------------------------------------------------------------------------------------
bool gt_InitHelpPanel_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    PlayerGroupLoopBegin(PlayerGroupAll());
    while (!PlayerGroupLoopDone()) {
        TechTreeUnitHelpDefault(PlayerGroupLoopCurrent(), false);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "SCV", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "MULE", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "PlanetaryFortress", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "Marine", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "Marauder", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "Reaper", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "Ghost", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "Hellion", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "Bunker", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "MissileTurret", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "Hellion", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "SiegeTankSieged", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "SiegeTank", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "Thor", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "VikingAssault", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "VikingFighter", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "Medivac", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "Banshee", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "Raven", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "AutoTurret", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "PointDefenseDrone", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "Battlecruiser", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "Larva", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "Drone", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "Overlord", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "Queen", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "Zergling", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "Baneling", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "Roach", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "Overseer", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "Hydralisk", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "InfestorTerran", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "Changeling", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "NydusCanal", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "Mutalisk", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "Corruptor", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "Infestor", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "Ultralisk", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "BroodLord", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "Broodling", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "SpineCrawler", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "SporeCrawler", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "Probe", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "Zealot", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "Stalker", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "Sentry", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "Immortal", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "DarkTemplar", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "HighTemplar", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "Archon", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "PhotonCannon", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "Observer", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "Colossus", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "WarpPrism", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "Phoenix", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "VoidRay", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "Carrier", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "Interceptor", true);
        TechTreeUnitHelp(PlayerGroupLoopCurrent(), "Mothership", true);
        PlayerGroupLoopStep();
    }
    PlayerGroupLoopEnd();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_InitHelpPanel_Init () {
    gt_InitHelpPanel = TriggerCreate("gt_InitHelpPanel_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Lava Surge Music
//--------------------------------------------------------------------------------------------------
bool gt_LavaSurgeMusic_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    SoundtrackPlay(PlayerGroupAll(), c_soundtrackCategoryMusic, "TTosh01MusicEventA", c_soundtrackCueAny, c_soundtrackIndexAny, false);
    SoundtrackWait("TTosh01MusicEventA");
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_LavaSurgeMusic_Init () {
    gt_LavaSurgeMusic = TriggerCreate("gt_LavaSurgeMusic_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Camera Shake - Weak
//--------------------------------------------------------------------------------------------------
bool gt_CameraShakeWeak_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    PlayerGroupLoopBegin(PlayerGroupAll());
    while (!PlayerGroupLoopDone()) {
        CameraShakeStart(PlayerGroupLoopCurrent(), c_cameraPositionTarget, c_cameraDirectionZ, 0.05, 2.0, 100.0, 3.0);
        PlayerGroupLoopStep();
    }
    PlayerGroupLoopEnd();
    WaterSetState("Template 1|Alternate Setting 1", 15.0, c_wtcLinear);
    GameSetLighting("TTosh01Warning", 15.0);
    Wait(2.0, c_timeGame);
    libNtve_gf_PlayAnimationOnDoodadsInRegion(RegionEntireMap(), "TTosh01FlameGeyser", "StandWork", "Stand Work", c_animFlagPlayForever, c_animTimeDefault);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_CameraShakeWeak_Init () {
    gt_CameraShakeWeak = TriggerCreate("gt_CameraShakeWeak_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Camera Shake - Strong
//--------------------------------------------------------------------------------------------------
bool gt_CameraShakeStrong_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    PlayerGroupLoopBegin(PlayerGroupAll());
    while (!PlayerGroupLoopDone()) {
        CameraShakeStart(PlayerGroupLoopCurrent(), c_cameraPositionTarget, c_cameraDirectionZ, 0.1, 2.0, 100.0, 4.0);
        PlayerGroupLoopStep();
    }
    PlayerGroupLoopEnd();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_CameraShakeStrong_Init () {
    gt_CameraShakeStrong = TriggerCreate("gt_CameraShakeStrong_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Camera Shake - During Lava
//--------------------------------------------------------------------------------------------------
bool gt_CameraShakeDuringLava_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    PlayerGroupLoopBegin(PlayerGroupAll());
    while (!PlayerGroupLoopDone()) {
        CameraShakeStart(PlayerGroupLoopCurrent(), c_cameraPositionTarget, c_cameraDirectionZ, 0.1, 2.0, 100.0, 4.0);
        PlayerGroupLoopStep();
    }
    PlayerGroupLoopEnd();
    Wait(4.0, c_timeGame);
    PlayerGroupLoopBegin(PlayerGroupAll());
    while (!PlayerGroupLoopDone()) {
        CameraShakeStart(PlayerGroupLoopCurrent(), c_cameraPositionTarget, c_cameraDirectionZ, 0.06, 2.0, 100.0, 2.0);
        PlayerGroupLoopStep();
    }
    PlayerGroupLoopEnd();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_CameraShakeDuringLava_Init () {
    gt_CameraShakeDuringLava = TriggerCreate("gt_CameraShakeDuringLava_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Create Lava Deaths Leaderboard
//--------------------------------------------------------------------------------------------------
bool gt_CreateLavaDeathsLeaderboard_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    BoardCreate(2, 1, StringExternal("Param/Value/5C98627F"), Color(100.00, 100.00, 100.00));
    gv_lavaDeathsBoard = BoardLastCreated();
    BoardSetState(gv_lavaDeathsBoard, PlayerGroupAll(), c_boardStateShowTitle, false);
    BoardSetState(gv_lavaDeathsBoard, PlayerGroupAll(), c_boardStateShowHeader, false);
    BoardSetPosition(gv_lavaDeathsBoard, 475, 50);
    BoardItemSetText(gv_lavaDeathsBoard, 1, 1, StringExternal("Param/Value/474382AE"));
    BoardItemSetText(gv_lavaDeathsBoard, 2, 1, IntToText(gv_lavaDeaths));
    BoardItemSetTextColor(gv_lavaDeathsBoard, 2, 1, Color(100.00, 0.00, 0.00));
    BoardMinimizeShow(gv_lavaDeathsBoard, PlayerGroupAll(), false);
    BoardSetState(gv_lavaDeathsBoard, PlayerGroupAll(), c_boardStateShowing, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_CreateLavaDeathsLeaderboard_Init () {
    gt_CreateLavaDeathsLeaderboard = TriggerCreate("gt_CreateLavaDeathsLeaderboard_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Update Lava Deaths Board
//--------------------------------------------------------------------------------------------------
bool gt_UpdateLavaDeathsBoard_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((EventUnitDamageSourcePlayer() == 15))) {
            return false;
        }
    }

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

    gv_lavaDeaths=gv_lavaDeaths + 1;
    gv_tempLavaDeaths=gv_tempLavaDeaths + 1;
    BoardItemSetText(gv_lavaDeathsBoard, 2, 1, IntToText(gv_lavaDeaths));
    TriggerExecute(gt_PlayLavaDeathSound, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_UpdateLavaDeathsBoard_Init () {
    gt_UpdateLavaDeathsBoard = TriggerCreate("gt_UpdateLavaDeathsBoard_Func");
    TriggerAddEventUnitDied(gt_UpdateLavaDeathsBoard, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Play Lava Death Sound
//--------------------------------------------------------------------------------------------------
bool gt_PlayLavaDeathSound_Func (bool testConds, bool runActions) {
    int auto381A303C_val;

    // Variable Declarations
    int lv_random;

    // Variable Initialization
    lv_random = 0;

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

    if ((gv_tempLavaDeaths == 20)) {
        lv_random = RandomInt(1, 3);
        auto381A303C_val = lv_random;
        if (auto381A303C_val == 1) {
            Wait(0.5, c_timeGame);
            SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryCombat, 20.0, 0.2);
            SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryDeath, 20.0, 0.2);
            SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryMusic, 20.0, 0.2);
            SoundPlay(SoundLink("ModUtilityVoiceModUtilityVoice00153", -1), PlayerGroupAll(), 200.0, 0.0);
            SoundWait(SoundLastPlayed(), 0.0, c_soundOffsetEnd);
            libNtve_gf_SetAllSoundChannelVolumes(2, PlayerGroupAll(), 0.0);
            gv_tempLavaDeaths = 0;
        }
        else if (auto381A303C_val == 2) {
            Wait(0.5, c_timeGame);
            SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryCombat, 20.0, 0.2);
            SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryDeath, 20.0, 0.2);
            SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryMusic, 20.0, 0.2);
            SoundPlay(SoundLink("ModUtilityVoiceModUtilityVoice00154", -1), PlayerGroupAll(), 200.0, 0.0);
            SoundWait(SoundLastPlayed(), 0.0, c_soundOffsetEnd);
            libNtve_gf_SetAllSoundChannelVolumes(2, PlayerGroupAll(), 0.0);
            gv_tempLavaDeaths = 0;
        }
        else if (auto381A303C_val == 3) {
            Wait(0.5, c_timeGame);
            SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryCombat, 20.0, 0.2);
            SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryDeath, 20.0, 0.2);
            SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryMusic, 20.0, 0.2);
            SoundPlay(SoundLink("ModUtilityVoiceModUtilityVoice00149", -1), PlayerGroupAll(), 200.0, 0.0);
            SoundWait(SoundLastPlayed(), 0.0, c_soundOffsetEnd);
            libNtve_gf_SetAllSoundChannelVolumes(2, PlayerGroupAll(), 0.0);
            gv_tempLavaDeaths = 0;
        }
        else {
        }
    }
    else {
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_PlayLavaDeathSound_Init () {
    gt_PlayLavaDeathSound = TriggerCreate("gt_PlayLavaDeathSound_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Lava Turns ON
//--------------------------------------------------------------------------------------------------
bool gt_LavaTurnsON_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((gv_lowGroundIsSafe == true))) {
            return false;
        }

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

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

    TriggerEnable(TriggerGetCurrent(), false);
    gv_lavaSurgeCounter=gv_lavaSurgeCounter + 1;
    BoardSetState(gv_lavaDeathsBoard, PlayerGroupAll(), c_boardStateShowing, true);
    TriggerExecute(gt_CameraShakeDuringLava, true, false);
    SoundPlay(SoundLink("TUILavaRising", -1), PlayerGroupAll(), 100.0, 0.0);
    WaterSetState("Template 1|Alternate Setting 2", 4.0, c_wtcLinear);
    GameSetLighting("TTosh01Eruption", 4.0);
    libNtve_gf_ClearAnimationOnDoodadsInRegion(RegionEntireMap(), "TTosh01FlameGeyser", "StandWork");
    libNtve_gf_PlayAnimationOnDoodadsInRegion(RegionEntireMap(), "CharAshWeather", c_animNameDefault, "Stand", c_animFlagPlayForever, c_animTimeDefault);
    Wait(2.0, c_timeGame);
    UnitGroupLoopBegin(UnitGroup("NaturalMinerals", 0, RegionPlayableMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0));
    while (!UnitGroupLoopDone()) {
        UnitRemove(UnitGroupLoopCurrent());
        UnitGroupLoopStep();
    }
    UnitGroupLoopEnd();
    gv_lowGroundIsSafe = false;
    TriggerEnable(gt_LavaDamage, true);
    TimerStart(gv_lavaTimer, 15.0, false, c_timeGame);
    Wait(2.0, c_timeGame);
    TriggerEnable(gt_LavaTurnsOFF, true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_LavaTurnsON_Init () {
    gt_LavaTurnsON = TriggerCreate("gt_LavaTurnsON_Func");
    TriggerAddEventTimer(gt_LavaTurnsON, gv_lavaTimer);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Lava Turns OFF
//--------------------------------------------------------------------------------------------------
bool gt_LavaTurnsOFF_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((gv_lowGroundIsSafe == false))) {
            return false;
        }

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

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

    TriggerEnable(TriggerGetCurrent(), false);
    SoundPlay(SoundLink("TUILavaRising", -1), PlayerGroupAll(), 100.0, 0.0);
    WaterSetState("Template 1|[Default]", 10.0, c_wtcLinear);
    GameSetLighting("TTosh01Normal", 10.0);
    libNtve_gf_PlayAnimationOnDoodadsInRegion(RegionEntireMap(), "CharAshWeather", c_animNameDefault, "Death", c_animFlagPlayForever, c_animTimeDefault);
    Wait(2.0, c_timeGame);
    gv_lowGroundIsSafe = true;
    TriggerEnable(gt_LavaDamage, false);
    gv_lavaInterval = RandomFixed(120.0, 240.0);
    TimerStart(gv_warning01Timer, (gv_lavaInterval - 30.0), false, c_timeGame);
    TimerStart(gv_warning02Timer, (gv_lavaInterval - 10.0), false, c_timeGame);
    TimerStart(gv_lavaTimer, gv_lavaInterval, false, c_timeGame);
    BoardSetState(gv_lavaDeathsBoard, PlayerGroupAll(), c_boardStateShowing, false);
    BoardItemSetText(gv_lavaDeathsBoard, 2, 1, IntToText(gv_lavaDeaths));
    TriggerExecute(gt_InitLavaMineralRegions, true, false);
    TriggerExecute(gt_SpawnRandomMinerals, true, false);
    Wait(2.0, c_timeGame);
    TriggerEnable(gt_LavaTurnsON, true);
    TriggerExecute(gt_TransmissionItsSafeQ, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_LavaTurnsOFF_Init () {
    gt_LavaTurnsOFF = TriggerCreate("gt_LavaTurnsOFF_Func");
    TriggerEnable(gt_LavaTurnsOFF, false);
    TriggerAddEventTimer(gt_LavaTurnsOFF, gv_lavaTimer);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Lava Damage
//--------------------------------------------------------------------------------------------------
bool gt_LavaDamage_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unitgroup lv_tempGroup;

    // Variable Initialization
    lv_tempGroup = UnitGroupEmpty();

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

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

    lv_tempGroup = UnitGroup(null, c_playerAny, RegionEntireMap(), UnitFilter((1 << c_targetFilterGround), 0, (1 << c_targetFilterRawResource) | (1 << c_targetFilterHarvestableResource) | (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)) | (1 << (c_targetFilterInvulnerable - 32))), 0);
    UnitGroupLoopBegin(UnitGroup("Colossus", c_playerAny, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)) | (1 << (c_targetFilterInvulnerable - 32))), 0));
    while (!UnitGroupLoopDone()) {
        UnitGroupAdd(lv_tempGroup, UnitGroupLoopCurrent());
        UnitGroupLoopStep();
    }
    UnitGroupLoopEnd();
    UnitGroupLoopBegin(lv_tempGroup);
    while (!UnitGroupLoopDone()) {
        if ((WorldHeight(c_heightMapGround, UnitGetPosition(UnitGroupLoopCurrent())) <= 8.8)) {
            UnitBehaviorAddPlayer(UnitGroupLoopCurrent(), "LavaDamage", 15, 1);
        }
        else {
        }
        UnitGroupLoopStep();
    }
    UnitGroupLoopEnd();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_LavaDamage_Init () {
    gt_LavaDamage = TriggerCreate("gt_LavaDamage_Func");
    TriggerEnable(gt_LavaDamage, false);
    TriggerAddEventTimePeriodic(gt_LavaDamage, 0.5, c_timeGame);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Transmission - Lava Warning 01 Q
//--------------------------------------------------------------------------------------------------
bool gt_TransmissionLavaWarning01Q_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerExecute(gt_CameraShakeWeak, true, false);
    TriggerExecute(gt_LavaSurgeMusic, true, false);
    TriggerQueueEnter();
    SoundPlay(SoundLink("UI_TerranKlaxonAlert", -1), PlayerGroupAll(), 100.0, 0.0);
    SoundWait(SoundLastPlayed(), 1.0, c_soundOffsetEnd);
    libNtve_gf_SetAllSoundChannelVolumes(1, PlayerGroupAll(), 0.0);
    libLbty_gf_PlayTransmissionCueSound(PlayerGroupAll());
    // Transmission - SoundLink("TTosh01Adjutant00010", -1)
    libNtve_gf_SendTransmissionSimple(TransmissionSourceFromModel(null), libNtve_gf_CinematicPortrait(4), SoundLink("TTosh01Adjutant00010", -1), 0.0, c_transmissionDurationAdd, true);
    libNtve_gf_SetAllSoundChannelVolumes(2, PlayerGroupAll(), 0.0);
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_TransmissionLavaWarning01Q_Init () {
    gt_TransmissionLavaWarning01Q = TriggerCreate("gt_TransmissionLavaWarning01Q_Func");
    TriggerAddEventTimer(gt_TransmissionLavaWarning01Q, gv_warning01Timer);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Transmission - Lava Warning 02 Q
//--------------------------------------------------------------------------------------------------
bool gt_TransmissionLavaWarning02Q_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerExecute(gt_CameraShakeStrong, true, false);
    TriggerQueueEnter();
    libNtve_gf_SetAllSoundChannelVolumes(1, PlayerGroupAll(), 0.0);
    libLbty_gf_PlayTransmissionCueSound(PlayerGroupAll());
    // Transmission - SoundLink("TTosh01Adjutant00013", -1)
    libNtve_gf_SendTransmissionSimple(TransmissionSourceFromModel(null), libNtve_gf_CinematicPortrait(4), SoundLink("TTosh01Adjutant00013", -1), 0.0, c_transmissionDurationAdd, true);
    libNtve_gf_SetAllSoundChannelVolumes(2, PlayerGroupAll(), 0.0);
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_TransmissionLavaWarning02Q_Init () {
    gt_TransmissionLavaWarning02Q = TriggerCreate("gt_TransmissionLavaWarning02Q_Func");
    TriggerAddEventTimer(gt_TransmissionLavaWarning02Q, gv_warning02Timer);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Transmission - "It's Safe" Q
//--------------------------------------------------------------------------------------------------
bool gt_TransmissionItsSafeQ_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerQueueEnter();
    libNtve_gf_SetAllSoundChannelVolumes(1, PlayerGroupAll(), 0.0);
    libLbty_gf_PlayTransmissionCueSound(PlayerGroupAll());
    // Transmission - SoundLink("TTosh01Adjutant00037", -1)
    libNtve_gf_SendTransmissionSimple(TransmissionSourceFromModel(null), libNtve_gf_CinematicPortrait(4), SoundLink("TTosh01Adjutant00037", -1), 0.0, c_transmissionDurationAdd, true);
    libNtve_gf_SetAllSoundChannelVolumes(2, PlayerGroupAll(), 0.0);
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_TransmissionItsSafeQ_Init () {
    gt_TransmissionItsSafeQ = TriggerCreate("gt_TransmissionItsSafeQ_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Create Mineral Count Board
//--------------------------------------------------------------------------------------------------
bool gt_CreateMineralCountBoard_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_i;

    // Variable Initialization
    lv_i = 0;

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

    BoardCreate(1, 8, StringExternal("Param/Value/36969D24"), Color(0.00, 100.00, 0.00));
    gv_minerals_Needed_Board = BoardLastCreated();
    BoardSetState(gv_minerals_Needed_Board, PlayerGroupAll(), c_boardStateShowTitle, false);
    BoardItemSetText(gv_minerals_Needed_Board, 1, c_boardRowHeader, (StringExternal("Param/Value/8F6014FB") + FormatNumber(gv_mINERALS_NEEDED)));
    BoardItemSetFontSize(gv_minerals_Needed_Board, 1, c_boardRowHeader, 18);
    BoardItemSetText(gv_minerals_Needed_Board, 1, 1, (StringExternal("Param/Value/C1073027") + IntToText(gv_northTeamMinerals)));
    BoardItemSetTextColor(gv_minerals_Needed_Board, 1, 1, Color(100.00, 100.00, 100.00));
    BoardItemSetFontSize(gv_minerals_Needed_Board, 1, 1, 16);
    BoardItemSetProgressShow(gv_minerals_Needed_Board, 1, 1, true);
    BoardItemSetProgressRange(gv_minerals_Needed_Board, 1, 1, 0.0, IntToFixed(gv_mINERALS_NEEDED));
    BoardItemSetProgressColor(gv_minerals_Needed_Board, 1, 1, Color(0.00, 100.00, 100.00), 1);
    lv_i = 2;
    PlayerGroupLoopBegin(gv_northTeam);
    while (!PlayerGroupLoopDone()) {
        BoardItemSetText(gv_minerals_Needed_Board, 1, lv_i, (TextWithColor(PlayerName(PlayerGroupLoopCurrent()), libNtve_gf_ConvertPlayerColorToColor(PlayerGetColorIndex(PlayerGroupLoopCurrent(), false))) + StringExternal("Param/Value/5D3134AB") + IntToText(PlayerGetPropertyInt(PlayerGroupLoopCurrent(), c_playerPropMinerals))));
        BoardItemSetFontSize(gv_minerals_Needed_Board, 1, lv_i, 16);
        lv_i=lv_i + 1;
        PlayerGroupLoopStep();
    }
    PlayerGroupLoopEnd();
    BoardItemSetText(gv_minerals_Needed_Board, 1, 5, (StringExternal("Param/Value/89F97838") + IntToText(gv_southTeamMinerals)));
    BoardItemSetTextColor(gv_minerals_Needed_Board, 1, 5, Color(100.00, 100.00, 100.00));
    BoardItemSetFontSize(gv_minerals_Needed_Board, 1, 5, 16);
    BoardItemSetProgressShow(gv_minerals_Needed_Board, 1, 5, true);
    BoardItemSetProgressRange(gv_minerals_Needed_Board, 1, 5, 0.0, IntToFixed(gv_mINERALS_NEEDED));
    BoardItemSetProgressColor(gv_minerals_Needed_Board, 1, 5, Color(100.00, 0.00, 0.00), 1);
    BoardItemSetProgressValue(gv_minerals_Needed_Board, 1, 2, IntToFixed(gv_northTeamMinerals));
    BoardItemSetProgressValue(gv_minerals_Needed_Board, 1, 5, IntToFixed(gv_southTeamMinerals));
    BoardItemSetIcon(gv_minerals_Needed_Board, 1, 1, "Assets\\Textures\\icon-mineral-terran.dds", false);
    BoardItemSetIcon(gv_minerals_Needed_Board, 1, 5, "Assets\\Textures\\icon-mineral-zerg.dds", false);
    lv_i = 6;
    PlayerGroupLoopBegin(gv_southTeam);
    while (!PlayerGroupLoopDone()) {
        BoardItemSetText(gv_minerals_Needed_Board, 1, lv_i, (TextWithColor(PlayerName(PlayerGroupLoopCurrent()), libNtve_gf_ConvertPlayerColorToColor(PlayerGetColorIndex(PlayerGroupLoopCurrent(), false))) + StringExternal("Param/Value/D62E6A43") + IntToText(PlayerGetPropertyInt(PlayerGroupLoopCurrent(), c_playerPropMinerals))));
        BoardItemSetFontSize(gv_minerals_Needed_Board, 1, lv_i, 16);
        lv_i=lv_i + 1;
        PlayerGroupLoopStep();
    }
    PlayerGroupLoopEnd();
    BoardMinimizeShow(gv_minerals_Needed_Board, PlayerGroupAll(), true);
    SoundPlay(SoundLink("TUI_StarmapMenuPopup", -1), PlayerGroupAll(), 100.0, 0.0);
    TriggerEnable(gt_UpdateMineralCountBoard, true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_CreateMineralCountBoard_Init () {
    gt_CreateMineralCountBoard = TriggerCreate("gt_CreateMineralCountBoard_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Update Mineral Count Board
//--------------------------------------------------------------------------------------------------
bool gt_UpdateMineralCountBoard_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_i;

    // Variable Initialization
    lv_i = 0;

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

    gv_northTeamMinerals = 0;
    gv_southTeamMinerals = 0;
    PlayerGroupLoopBegin(gv_northTeam);
    while (!PlayerGroupLoopDone()) {
        gv_northTeamMinerals=gv_northTeamMinerals + PlayerGetPropertyInt(PlayerGroupLoopCurrent(), c_playerPropMinerals);
        PlayerGroupLoopStep();
    }
    PlayerGroupLoopEnd();
    PlayerGroupLoopBegin(gv_southTeam);
    while (!PlayerGroupLoopDone()) {
        gv_southTeamMinerals=gv_southTeamMinerals + PlayerGetPropertyInt(PlayerGroupLoopCurrent(), c_playerPropMinerals);
        PlayerGroupLoopStep();
    }
    PlayerGroupLoopEnd();
    BoardItemSetProgressValue(gv_minerals_Needed_Board, 1, 1, IntToFixed(gv_northTeamMinerals));
    BoardItemSetProgressValue(gv_minerals_Needed_Board, 1, 5, IntToFixed(gv_southTeamMinerals));
    BoardItemSetText(gv_minerals_Needed_Board, 1, 1, (StringExternal("Param/Value/34518CBD") + IntToText(gv_northTeamMinerals)));
    BoardItemSetText(gv_minerals_Needed_Board, 1, 5, (StringExternal("Param/Value/75B50308") + IntToText(gv_southTeamMinerals)));
    lv_i = 2;
    PlayerGroupLoopBegin(gv_northTeam);
    while (!PlayerGroupLoopDone()) {
        BoardItemSetText(gv_minerals_Needed_Board, 1, lv_i, (TextWithColor(PlayerName(PlayerGroupLoopCurrent()), libNtve_gf_ConvertPlayerColorToColor(PlayerGetColorIndex(PlayerGroupLoopCurrent(), false))) + StringExternal("Param/Value/8AA24866") + IntToText(PlayerGetPropertyInt(PlayerGroupLoopCurrent(), c_playerPropMinerals))));
        lv_i=lv_i + 1;
        PlayerGroupLoopStep();
    }
    PlayerGroupLoopEnd();
    lv_i = 6;
    PlayerGroupLoopBegin(gv_southTeam);
    while (!PlayerGroupLoopDone()) {
        BoardItemSetText(gv_minerals_Needed_Board, 1, lv_i, (TextWithColor(PlayerName(PlayerGroupLoopCurrent()), libNtve_gf_ConvertPlayerColorToColor(PlayerGetColorIndex(PlayerGroupLoopCurrent(), false))) + StringExternal("Param/Value/3FB472E7") + IntToText(PlayerGetPropertyInt(PlayerGroupLoopCurrent(), c_playerPropMinerals))));
        lv_i=lv_i + 1;
        PlayerGroupLoopStep();
    }
    PlayerGroupLoopEnd();
    if ((gv_northTeamMinerals >= 10000)) {
        TriggerExecute(gt_WarningNTeamCloseToVictory, true, false);
    }
    else {
    }
    if ((gv_southTeamMinerals >= 10000)) {
        TriggerExecute(gt_WarningSTeamCloseToVictory, true, false);
    }
    else {
    }
    if ((gv_northTeamMinerals >= gv_mINERALS_NEEDED)) {
        TriggerEnable(TriggerGetCurrent(), false);
        PlayerGroupLoopBegin(gv_northTeam);
        while (!PlayerGroupLoopDone()) {
            GameOver(PlayerGroupLoopCurrent(), c_gameOverVictory, true, true);
            PlayerGroupLoopStep();
        }
        PlayerGroupLoopEnd();
        PlayerGroupLoopBegin(gv_southTeam);
        while (!PlayerGroupLoopDone()) {
            GameOver(PlayerGroupLoopCurrent(), c_gameOverDefeat, true, true);
            PlayerGroupLoopStep();
        }
        PlayerGroupLoopEnd();
    }
    else {
        if ((gv_southTeamMinerals >= gv_mINERALS_NEEDED)) {
            TriggerEnable(TriggerGetCurrent(), false);
            PlayerGroupLoopBegin(gv_southTeam);
            while (!PlayerGroupLoopDone()) {
                GameOver(PlayerGroupLoopCurrent(), c_gameOverVictory, true, true);
                PlayerGroupLoopStep();
            }
            PlayerGroupLoopEnd();
            PlayerGroupLoopBegin(gv_northTeam);
            while (!PlayerGroupLoopDone()) {
                GameOver(PlayerGroupLoopCurrent(), c_gameOverDefeat, true, true);
                PlayerGroupLoopStep();
            }
            PlayerGroupLoopEnd();
        }
        else {
        }
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_UpdateMineralCountBoard_Init () {
    gt_UpdateMineralCountBoard = TriggerCreate("gt_UpdateMineralCountBoard_Func");
    TriggerAddEventTimePeriodic(gt_UpdateMineralCountBoard, 0.25, c_timeGame);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Init Lava Mineral Regions
//--------------------------------------------------------------------------------------------------
bool gt_InitLavaMineralRegions_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    gv_maxMineralRegions = 0;
    gv_mineralRegions[1] = RegionFromId(1);
    gv_maxMineralRegions=gv_maxMineralRegions + 1;
    gv_mineralRegions[2] = RegionFromId(4);
    gv_maxMineralRegions=gv_maxMineralRegions + 1;
    gv_mineralRegions[3] = RegionFromId(12);
    gv_maxMineralRegions=gv_maxMineralRegions + 1;
    gv_mineralRegions[4] = RegionFromId(2);
    gv_maxMineralRegions=gv_maxMineralRegions + 1;
    gv_mineralRegions[5] = RegionFromId(5);
    gv_maxMineralRegions=gv_maxMineralRegions + 1;
    gv_mineralRegions[6] = RegionFromId(6);
    gv_maxMineralRegions=gv_maxMineralRegions + 1;
    gv_mineralRegions[7] = RegionFromId(3);
    gv_maxMineralRegions=gv_maxMineralRegions + 1;
    gv_mineralRegions[8] = RegionFromId(21);
    gv_maxMineralRegions=gv_maxMineralRegions + 1;
    gv_mineralRegions[9] = RegionFromId(8);
    gv_maxMineralRegions=gv_maxMineralRegions + 1;
    gv_mineralRegions[10] = RegionFromId(9);
    gv_maxMineralRegions=gv_maxMineralRegions + 1;
    gv_mineralRegions[11] = RegionFromId(23);
    gv_maxMineralRegions=gv_maxMineralRegions + 1;
    gv_mineralRegions[12] = RegionFromId(11);
    gv_maxMineralRegions=gv_maxMineralRegions + 1;
    gv_mineralRegions[13] = RegionFromId(13);
    gv_maxMineralRegions=gv_maxMineralRegions + 1;
    gv_mineralRegions[14] = RegionFromId(15);
    gv_maxMineralRegions=gv_maxMineralRegions + 1;
    gv_mineralRegions[15] = RegionFromId(14);
    gv_maxMineralRegions=gv_maxMineralRegions + 1;
    gv_mineralRegions[16] = RegionFromId(22);
    gv_maxMineralRegions=gv_maxMineralRegions + 1;
    gv_mineralRegions[17] = RegionFromId(17);
    gv_maxMineralRegions=gv_maxMineralRegions + 1;
    gv_mineralRegions[18] = RegionFromId(16);
    gv_maxMineralRegions=gv_maxMineralRegions + 1;
    gv_mineralRegions[19] = RegionFromId(7);
    gv_maxMineralRegions=gv_maxMineralRegions + 1;
    gv_mineralRegions[20] = RegionFromId(10);
    gv_maxMineralRegions=gv_maxMineralRegions + 1;
    gv_mineralRegions[21] = RegionFromId(18);
    gv_maxMineralRegions=gv_maxMineralRegions + 1;
    gv_mineralRegions[22] = RegionFromId(19);
    gv_maxMineralRegions=gv_maxMineralRegions + 1;
    gv_mineralRegions[23] = RegionFromId(20);
    gv_maxMineralRegions=gv_maxMineralRegions + 1;
    gv_mineralRegions[24] = RegionFromId(24);
    gv_maxMineralRegions=gv_maxMineralRegions + 1;
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_InitLavaMineralRegions_Init () {
    gt_InitLavaMineralRegions = TriggerCreate("gt_InitLavaMineralRegions_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Spawn Random Minerals
//--------------------------------------------------------------------------------------------------
bool gt_SpawnRandomMinerals_Func (bool testConds, bool runActions) {
    int auto87042992_n;
    int auto87042992_i;

    // Variable Declarations
    region lv_currentRegion;
    int lv_mineralSpawnsNumber;

    // Variable Initialization
    lv_currentRegion = null;
    lv_mineralSpawnsNumber = 0;

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

    if ((gv_lavaSurgeCounter == 1)) {
        lv_mineralSpawnsNumber = 8;
        TriggerExecute(gt_TipMineralPickups, true, false);
    }
    else if ((gv_lavaSurgeCounter == 2)) {
        lv_mineralSpawnsNumber = 10;
    }
    else if ((gv_lavaSurgeCounter >= 3)) {
        lv_mineralSpawnsNumber = 12;
    }
    auto87042992_n = lv_mineralSpawnsNumber;
    auto87042992_i = 1;
    while (auto87042992_i <= auto87042992_n) {
        gv_randomPickedRegion = RandomInt(1, gv_maxMineralRegions);
        lv_currentRegion = gv_mineralRegions[gv_randomPickedRegion];
        gf_SpawnRandomMineralShard(lv_currentRegion);
        gv_mineralRegions[gv_randomPickedRegion] = gv_mineralRegions[gv_maxMineralRegions];
        gv_maxMineralRegions=gv_maxMineralRegions - 1;
        auto87042992_i = auto87042992_i + 1;
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_SpawnRandomMinerals_Init () {
    gt_SpawnRandomMinerals = TriggerCreate("gt_SpawnRandomMinerals_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Warning - N Team Close To Victory
//--------------------------------------------------------------------------------------------------
bool gt_WarningNTeamCloseToVictory_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    SoundPlay(SoundLink("UI_TerranKlaxonAlert", -1), gv_southTeam, 100.0, 0.0);
    UIDisplayMessage(gv_southTeam, c_messageAreaSubtitle, gv_textInitialWarning);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_WarningNTeamCloseToVictory_Init () {
    gt_WarningNTeamCloseToVictory = TriggerCreate("gt_WarningNTeamCloseToVictory_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Warning - S Team Close To Victory
//--------------------------------------------------------------------------------------------------
bool gt_WarningSTeamCloseToVictory_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    SoundPlay(SoundLink("UI_TerranKlaxonAlert", -1), gv_northTeam, 100.0, 0.0);
    UIDisplayMessage(gv_northTeam, c_messageAreaSubtitle, gv_textInitialWarning);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_WarningSTeamCloseToVictory_Init () {
    gt_WarningSTeamCloseToVictory = TriggerCreate("gt_WarningSTeamCloseToVictory_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Resource Pickups
//--------------------------------------------------------------------------------------------------
bool gt_ResourcePickups_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((UnitGetType(EventUnit()) == "NaturalMinerals"))) {
            return false;
        }

        if (!(((UnitGetOwner(EventUnitTargetUnit()) == 1) || (UnitGetOwner(EventUnitTargetUnit()) == 2) || (UnitGetOwner(EventUnitTargetUnit()) == 3) || (UnitGetOwner(EventUnitTargetUnit()) == 4) || (UnitGetOwner(EventUnitTargetUnit()) == 5) || (UnitGetOwner(EventUnitTargetUnit()) == 6)))) {
            return false;
        }
    }

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

    UnitRemove(EventUnit());
    SoundPlay(SoundLink("UI_ResourcePickupLocal", -1), PlayerGroupSingle(UnitGetOwner(EventUnitTargetUnit())), 100.0, 0.0);
    PlayerModifyPropertyInt(UnitGetOwner(EventUnitTargetUnit()), c_playerPropMinerals, c_playerPropOperAdd, 100);
    PlayerScoreValueSetFromInt(UnitGetOwner(EventUnitTargetUnit()), "MineralsCollected", 100); 
    TextTagCreate(StringExternal("Param/Value/06F4E395"), 28, UnitGetPosition(EventUnit()), 1.5, true, false, PlayerGroupSingle(UnitGetOwner(EventUnitTargetUnit())));
    TextTagSetVelocity(TextTagLastCreated(), 0.5, 90.0);
    Wait(3.0, c_timeGame);
    TextTagDestroy(TextTagLastCreated());
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_ResourcePickups_Init () {
    gt_ResourcePickups = TriggerCreate("gt_ResourcePickups_Func");
    TriggerAddEventUnitAbility(gt_ResourcePickups, null, AbilityCommand("Pickup", 0), c_unitAbilStageExecute, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Tip - Lava Mechanic
//--------------------------------------------------------------------------------------------------
bool gt_TipLavaMechanic_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerGetExecCount(TriggerGetCurrent()) == 0))) {
            return false;
        }
    }

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

    HelpPanelAddTip(PlayerGroupAll(), libNtve_gf_FormatTipTitle(StringExternal("Param/Value/8A7D213F"), 0), StringExternal("Param/Value/AF16FE78"), StringExternal("Param/Value/44C6CEFF"), "Assets\\Textures\\btn-tips-walloffire.dds");
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_TipLavaMechanic_Init () {
    gt_TipLavaMechanic = TriggerCreate("gt_TipLavaMechanic_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Tip - Mineral Pickups
//--------------------------------------------------------------------------------------------------
bool gt_TipMineralPickups_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((TriggerGetExecCount(TriggerGetCurrent()) == 0))) {
            return false;
        }
    }

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

    HelpPanelAddTip(PlayerGroupAll(), libNtve_gf_FormatTipTitle(StringExternal("Param/Value/376965C2"), 0), StringExternal("Param/Value/E27DB8D7"), StringExternal("Param/Value/1E7D8049"), "Assets\\Textures\\btn-tips-resourcecaches.dds");
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_TipMineralPickups_Init () {
    gt_TipMineralPickups = TriggerCreate("gt_TipMineralPickups_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger Initialization
//--------------------------------------------------------------------------------------------------
void InitTriggers () {
    gt_MeleeInitialization_Init();
    gt_InitHelpPanel_Init();
    gt_LavaSurgeMusic_Init();
    gt_CameraShakeWeak_Init();
    gt_CameraShakeStrong_Init();
    gt_CameraShakeDuringLava_Init();
    gt_CreateLavaDeathsLeaderboard_Init();
    gt_UpdateLavaDeathsBoard_Init();
    gt_PlayLavaDeathSound_Init();
    gt_LavaTurnsON_Init();
    gt_LavaTurnsOFF_Init();
    gt_LavaDamage_Init();
    gt_TransmissionLavaWarning01Q_Init();
    gt_TransmissionLavaWarning02Q_Init();
    gt_TransmissionItsSafeQ_Init();
    gt_CreateMineralCountBoard_Init();
    gt_UpdateMineralCountBoard_Init();
    gt_InitLavaMineralRegions_Init();
    gt_SpawnRandomMinerals_Init();
    gt_WarningNTeamCloseToVictory_Init();
    gt_WarningSTeamCloseToVictory_Init();
    gt_ResourcePickups_Init();
    gt_TipLavaMechanic_Init();
    gt_TipMineralPickups_Init();
}

//--------------------------------------------------------------------------------------------------
// Map Initialization
//--------------------------------------------------------------------------------------------------
void InitMap () {
    InitLibs();
    InitGlobals();
    InitCustomScript();
    InitTriggers();
}