//--------------------------------------------------------------------------------------------------
// Global Variables
//--------------------------------------------------------------------------------------------------
unitgroup gv_hellbat;
unitgroup gv_widowmine;
unitgroup gv_loki;
unitgroup gv_zeus;
unitgroup gv_siegeTank;
unitgroup gv_swarmHost;
unitgroup gv_raptorling;
unitgroup gv_ghost;
unitgroup gv_queen;
unitgroup gv_hybrid;
unitgroup gv_selendis;
unitgroup gv_dblZealot;


void InitGlobals () {
    int init_i;
    int init_j;


    gv_hellbat = UnitGroupEmpty();
    gv_widowmine = UnitGroupEmpty();
    gv_loki = UnitGroupEmpty();
    gv_zeus = UnitGroupEmpty();
    gv_siegeTank = UnitGroupEmpty();
    gv_swarmHost = UnitGroupEmpty();
    gv_raptorling = UnitGroupEmpty();
    gv_ghost = UnitGroupEmpty();
    gv_queen = UnitGroupEmpty();
    gv_hybrid = UnitGroupEmpty();
    gv_selendis = UnitGroupEmpty();
    gv_dblZealot = UnitGroupEmpty();

}

//--------------------------------------------------------------------------------------------------
// Trigger Variables
//--------------------------------------------------------------------------------------------------
trigger gt_UnitQueue;
trigger gt_UnitQueue2;
trigger gt_UnitQueue3;
trigger gt_Hellbat;
trigger gt_Hellbat2;
trigger gt_Widowmine;
trigger gt_Widowmine2;
trigger gt_Loki;
trigger gt_Loki2;
trigger gt_Zeus;
trigger gt_Zeus2;
trigger gt_SiegeTank;
trigger gt_SiegeTank2;
trigger gt_SwarmHost;
trigger gt_SwarmHost2;
trigger gt_Raptorling;
trigger gt_Raptorling2;
trigger gt_Ghost;
trigger gt_Ghost2;
trigger gt_Queen;
trigger gt_Queen2;
trigger gt_Hybrid;
trigger gt_Hybrid2;
trigger gt_Selendis;
trigger gt_Selendis2;
trigger gt_DblZealot;
trigger gt_DblZealot2;

//--------------------------------------------------------------------------------------------------
// Trigger: Unit Queue
//--------------------------------------------------------------------------------------------------
bool gt_UnitQueue_Func (bool testConds, bool runActions) { 

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

    if ((UnitGetType(EventUnit()) == "GhostAcademy")) {
        if ((UnitGroupHasUnit(gv_ghost, EventUnit()) == true)) {
            UnitIssueOrder(EventUnit(), Order(AbilityCommand("BarracksTrain", 6)), c_orderQueueReplace);
        }
        else {
            UnitIssueOrder(EventUnit(), Order(AbilityCommand("BarracksTrain", 7)), c_orderQueueReplace);
        }
    }
    else {
    }
    if ((UnitGetType(EventUnit()) == "SupplyDepot")) {
        if ((UnitGroupHasUnit(gv_siegeTank, EventUnit()) == true)) {
            UnitIssueOrder(EventUnit(), Order(AbilityCommand("FactoryTrain", 0)), c_orderQueueReplace);
        }
        else {
            UnitIssueOrder(EventUnit(), Order(AbilityCommand("FactoryTrain", 1)), c_orderQueueReplace);
        }
    }
    else {
    }
    if ((UnitGetType(EventUnit()) == "Armory")) {
        if ((UnitGroupHasUnit(gv_zeus, EventUnit()) == true)) {
            UnitIssueOrder(EventUnit(), Order(AbilityCommand("FactoryTrain", 13)), c_orderQueueReplace);
        }
        else {
            UnitIssueOrder(EventUnit(), Order(AbilityCommand("FactoryTrain", 4)), c_orderQueueReplace);
        }
    }
    else {
    }
    if ((UnitGetType(EventUnit()) == "Factory")) {
        if ((UnitGroupHasUnit(gv_hellbat, EventUnit()) == true)) {
            UnitIssueOrder(EventUnit(), Order(AbilityCommand("FactoryTrain", 6)), c_orderQueueReplace);
        }
        if ((UnitGroupHasUnit(gv_widowmine, EventUnit()) == true)) {
            UnitIssueOrder(EventUnit(), Order(AbilityCommand("FactoryTrain", 7)), c_orderQueueReplace);
        }
        else {
            UnitIssueOrder(EventUnit(), Order(AbilityCommand("FactoryTrain", 5)), c_orderQueueReplace);
        }
    }
    else {
    }
    if ((UnitGetType(EventUnit()) == "FusionCore")) {
        if ((UnitGroupHasUnit(gv_loki, EventUnit()) == true)) {
            UnitIssueOrder(EventUnit(), Order(AbilityCommand("StarportTrain", 9)), c_orderQueueReplace);
        }
        else {
            UnitIssueOrder(EventUnit(), Order(AbilityCommand("StarportTrain", 3)), c_orderQueueReplace);
        }
    }
    else {
    }
    if ((UnitGetType(EventUnit()) == "SpawningPool") && (UnitQueueItemCount(EventUnit(), 1) == 0)) {
        if ((UnitGroupHasUnit(gv_raptorling, EventUnit()) == true)) {
            UnitIssueOrder(EventUnit(), Order(AbilityCommand("ZergTrain", 17)), c_orderQueueReplace);
        }
        else {
            UnitIssueOrder(EventUnit(), Order(AbilityCommand("ZergTrain", 0)), c_orderQueueReplace);
        }
    }
    else {
    }
    if ((UnitGetType(EventUnit()) == "SpineCrawler")) {
        if ((UnitGroupHasUnit(gv_queen, EventUnit()) == true)) {
            UnitIssueOrder(EventUnit(), Order(AbilityCommand("ZergTrain", 13)), c_orderQueueReplace);
        }
        else {
            UnitIssueOrder(EventUnit(), Order(AbilityCommand("ZergTrain", 4)), c_orderQueueReplace);
        }
    }
    else {
    }
    if ((UnitGetType(EventUnit()) == "Gateway")) {
        if ((UnitGroupHasUnit(gv_dblZealot, EventUnit()) == true)) {
            UnitIssueOrder(EventUnit(), Order(AbilityCommand("GatewayTrain", 6)), c_orderQueueReplace);
        }
        else {
            UnitIssueOrder(EventUnit(), Order(AbilityCommand("GatewayTrain", 0)), c_orderQueueReplace);
        }
    }
    else {
    }
    if ((UnitGetType(EventUnit()) == "TemplarArchive")) {
        if ((UnitGroupHasUnit(gv_hybrid, EventUnit()) == true)) {
            UnitIssueOrder(EventUnit(), Order(AbilityCommand("ZergTrain", 19)), c_orderQueueReplace);
        }
        else {
            UnitIssueOrder(EventUnit(), Order(AbilityCommand("ZergTrain", 5)), c_orderQueueReplace);
        }
    }
    else {
    }
    if ((UnitGetType(EventUnit()) == "FleetBeacon")) {
        if ((UnitGroupHasUnit(gv_selendis, EventUnit()) == true)) {
            UnitIssueOrder(EventUnit(), Order(AbilityCommand("StargateTrain", 1)), c_orderQueueReplace);
        }
        else {
            UnitIssueOrder(EventUnit(), Order(AbilityCommand("StargateTrain", 2)), c_orderQueueReplace);
        }
    }
    else {
    }
    if ((UnitGetType(EventUnit()) == "LurkerDen")) {
        if ((UnitGroupHasUnit(gv_swarmHost, EventUnit()) == true)) {
            UnitIssueOrder(EventUnit(), Order(AbilityCommand("ZergTrain", 11)), c_orderQueueReplace);
        }
        else {
            UnitIssueOrder(EventUnit(), Order(AbilityCommand("ZergTrain", 6)), c_orderQueueReplace);
        }
    }
    else {
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_UnitQueue_Init () {
    gt_UnitQueue = TriggerCreate("gt_UnitQueue_Func");
    TriggerAddEventUnitTrainProgress(gt_UnitQueue, null, c_unitProgressStageComplete);
}
//--------------------------------------------------------------------------------------------------
// Trigger: Unit Queue 2
//--------------------------------------------------------------------------------------------------
bool gt_UnitQueue2_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    if ((UnitGetType(EventUnitProgressUnit()) == "GhostAcademy")) {
        UnitIssueOrder(EventUnitProgressUnit(), Order(AbilityCommand("BarracksTrain", 7)), c_orderQueueReplace);
    }
    else {
    }
    if ((UnitGetType(EventUnitProgressUnit()) == "SupplyDepot")) {
        UnitIssueOrder(EventUnitProgressUnit(), Order(AbilityCommand("FactoryTrain", 1)), c_orderQueueReplace);
    }
    else {
    }
    if ((UnitGetType(EventUnitProgressUnit()) == "Armory")) {
        UnitIssueOrder(EventUnitProgressUnit(), Order(AbilityCommand("FactoryTrain", 4)), c_orderQueueReplace);
    }
    else {
    }
    if ((UnitGetType(EventUnitProgressUnit()) == "Factory")) {
        UnitIssueOrder(EventUnitProgressUnit(), Order(AbilityCommand("FactoryTrain", 5)), c_orderQueueReplace);
    }
    else {
    }
    if ((UnitGetType(EventUnitProgressUnit()) == "FusionCore")) {
        UnitIssueOrder(EventUnitProgressUnit(), Order(AbilityCommand("StarportTrain", 3)), c_orderQueueReplace);
    }
    else {
    }
    if ((UnitGetType(EventUnitProgressUnit()) == "SpawningPool")) {
        UnitIssueOrder(EventUnitProgressUnit(), Order(AbilityCommand("ZergTrain", 0)), c_orderQueueReplace);
    }
    else {
    }
    if ((UnitGetType(EventUnitProgressUnit()) == "SpineCrawler")) {
        UnitIssueOrder(EventUnitProgressUnit(), Order(AbilityCommand("ZergTrain", 4)), c_orderQueueReplace);
    }
    else {
    }
    if ((UnitGetType(EventUnitProgressUnit()) == "Gateway")) {
        UnitIssueOrder(EventUnitProgressUnit(), Order(AbilityCommand("GatewayTrain", 0)), c_orderQueueReplace);
    }
    else {
    }
    if ((UnitGetType(EventUnitProgressUnit()) == "TemplarArchive")) {
        UnitIssueOrder(EventUnitProgressUnit(), Order(AbilityCommand("ZergTrain", 5)), c_orderQueueReplace);
    }
    else {
    }
    if ((UnitGetType(EventUnitProgressUnit()) == "FleetBeacon")) {
        UnitIssueOrder(EventUnitProgressUnit(), Order(AbilityCommand("StargateTrain", 2)), c_orderQueueReplace);
    }
    else {
    }
    if ((UnitGetType(EventUnitProgressUnit()) == "LurkerDen")) {
        UnitIssueOrder(EventUnitProgressUnit(), Order(AbilityCommand("ZergTrain", 6)), c_orderQueueReplace);
    }
    else {
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_UnitQueue2_Init () {
    gt_UnitQueue2 = TriggerCreate("gt_UnitQueue2_Func");
    TriggerAddEventUnitConstructProgress(gt_UnitQueue2, null, c_unitProgressStageComplete);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Unit Queue 3
//--------------------------------------------------------------------------------------------------
bool gt_UnitQueue3_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    UnitGroupLoopBegin(UnitGroup("GhostAcademy", c_playerAny, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0));
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        if ((UnitQueueItemCount(UnitGroupLoopCurrent(), 1) == 0)) {
            if ((UnitGroupHasUnit(gv_ghost, UnitGroupLoopCurrent()) == true)) {
                UnitIssueOrder(UnitGroupLoopCurrent(), Order(AbilityCommand("BarracksTrain", 6)), c_orderQueueReplace);
            }
            else {
                UnitIssueOrder(UnitGroupLoopCurrent(), Order(AbilityCommand("BarracksTrain", 7)), c_orderQueueReplace);
            }
        }
        else {
        }
    }
    UnitGroupLoopEnd();
    UnitGroupLoopBegin(UnitGroup("SupplyDepot", c_playerAny, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0));
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        if ((UnitQueueItemCount(UnitGroupLoopCurrent(), 1) == 0)) {
            if ((UnitGroupHasUnit(gv_siegeTank, UnitGroupLoopCurrent()) == true)) {
                UnitIssueOrder(UnitGroupLoopCurrent(), Order(AbilityCommand("FactoryTrain", 0)), c_orderQueueReplace);
            }
            else {
                UnitIssueOrder(UnitGroupLoopCurrent(), Order(AbilityCommand("FactoryTrain", 1)), c_orderQueueReplace);
            }
        }
        else {
        }
    }
    UnitGroupLoopEnd();
    UnitGroupLoopBegin(UnitGroup("Armory", c_playerAny, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0));
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        if ((UnitQueueItemCount(UnitGroupLoopCurrent(), 1) == 0)) {
            if ((UnitGroupHasUnit(gv_zeus, UnitGroupLoopCurrent()) == true)) {
                UnitIssueOrder(UnitGroupLoopCurrent(), Order(AbilityCommand("FactoryTrain", 13)), c_orderQueueReplace);
            }
            else {
                UnitIssueOrder(UnitGroupLoopCurrent(), Order(AbilityCommand("FactoryTrain", 4)), c_orderQueueReplace);
            }
        }
        else {
        }
    }
    UnitGroupLoopEnd();
    UnitGroupLoopBegin(UnitGroup("Factory", c_playerAny, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0));
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        if ((UnitQueueItemCount(UnitGroupLoopCurrent(), 1) == 0)) {
            if ((UnitGroupHasUnit(gv_hellbat, UnitGroupLoopCurrent()) == true)) {
                UnitIssueOrder(UnitGroupLoopCurrent(), Order(AbilityCommand("FactoryTrain", 6)), c_orderQueueReplace);
            }
            if ((UnitGroupHasUnit(gv_widowmine, UnitGroupLoopCurrent()) == true)) {
                UnitIssueOrder(UnitGroupLoopCurrent(), Order(AbilityCommand("FactoryTrain", 7)), c_orderQueueReplace);
            }
            else {
                UnitIssueOrder(UnitGroupLoopCurrent(), Order(AbilityCommand("FactoryTrain", 5)), c_orderQueueReplace);
            }
        }
        else {
        }
    }
    UnitGroupLoopEnd();
    UnitGroupLoopBegin(UnitGroup("FusionCore", c_playerAny, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0));
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        if ((UnitQueueItemCount(UnitGroupLoopCurrent(), 1) == 0)) {
            if ((UnitGroupHasUnit(gv_loki, UnitGroupLoopCurrent()) == true)) {
                UnitIssueOrder(UnitGroupLoopCurrent(), Order(AbilityCommand("StarportTrain", 9)), c_orderQueueReplace);
            }
            else {
                UnitIssueOrder(UnitGroupLoopCurrent(), Order(AbilityCommand("StarportTrain", 3)), c_orderQueueReplace);
            }
        }
        else {
        }
    }
    UnitGroupLoopEnd();
    UnitGroupLoopBegin(UnitGroup("SpawningPool", c_playerAny, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0));
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        if ((UnitQueueItemCount(UnitGroupLoopCurrent(), 1) == 0)) {
            if ((UnitGroupHasUnit(gv_raptorling, UnitGroupLoopCurrent()) == true)) {
                UnitIssueOrder(UnitGroupLoopCurrent(), Order(AbilityCommand("ZergTrain", 17)), c_orderQueueReplace);
            }
            else {
                UnitIssueOrder(UnitGroupLoopCurrent(), Order(AbilityCommand("ZergTrain", 0)), c_orderQueueReplace);
            }
        }
        else {
        }
    }
    UnitGroupLoopEnd();
    UnitGroupLoopBegin(UnitGroup("SpineCrawler", c_playerAny, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0));
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        if ((UnitQueueItemCount(UnitGroupLoopCurrent(), 1) == 0)) {
            if ((UnitGroupHasUnit(gv_queen, UnitGroupLoopCurrent()) == true)) {
                UnitIssueOrder(UnitGroupLoopCurrent(), Order(AbilityCommand("ZergTrain", 13)), c_orderQueueReplace);
            }
            else {
                UnitIssueOrder(UnitGroupLoopCurrent(), Order(AbilityCommand("ZergTrain", 4)), c_orderQueueReplace);
            }
        }
        else {
        }
    }
    UnitGroupLoopEnd();
    UnitGroupLoopBegin(UnitGroup("Gateway", c_playerAny, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0));
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        if ((UnitQueueItemCount(UnitGroupLoopCurrent(), 1) == 0)) {
            if ((UnitGroupHasUnit(gv_dblZealot, UnitGroupLoopCurrent()) == true)) {
                UnitIssueOrder(UnitGroupLoopCurrent(), Order(AbilityCommand("GatewayTrain", 6)), c_orderQueueReplace);
            }
            else {
                UnitIssueOrder(UnitGroupLoopCurrent(), Order(AbilityCommand("GatewayTrain", 0)), c_orderQueueReplace);
            }
        }
        else {
        }
    }
    UnitGroupLoopEnd();
    UnitGroupLoopBegin(UnitGroup("TemplarArchive", c_playerAny, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0));
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        if ((UnitQueueItemCount(UnitGroupLoopCurrent(), 1) == 0)) {
            if ((UnitGroupHasUnit(gv_hybrid, UnitGroupLoopCurrent()) == true)) {
                UnitIssueOrder(UnitGroupLoopCurrent(), Order(AbilityCommand("ZergTrain", 19)), c_orderQueueReplace);
            }
            else {
                UnitIssueOrder(UnitGroupLoopCurrent(), Order(AbilityCommand("ZergTrain", 5)), c_orderQueueReplace);
            }
        }
        else {
        }
    }
    UnitGroupLoopEnd();
    UnitGroupLoopBegin(UnitGroup("FleetBeacon", c_playerAny, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0));
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        if ((UnitQueueItemCount(UnitGroupLoopCurrent(), 1) == 0)) {
            if ((UnitGroupHasUnit(gv_selendis, UnitGroupLoopCurrent()) == true)) {
                UnitIssueOrder(UnitGroupLoopCurrent(), Order(AbilityCommand("StargateTrain", 1)), c_orderQueueReplace);
            }
            else {
                UnitIssueOrder(UnitGroupLoopCurrent(), Order(AbilityCommand("StargateTrain", 2)), c_orderQueueReplace);
            }
        }
        else {
        }
    }
    UnitGroupLoopEnd();
    UnitGroupLoopBegin(UnitGroup("LurkerDen", c_playerAny, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0));
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        if ((UnitQueueItemCount(UnitGroupLoopCurrent(), 1) == 0)) {
            if ((UnitGroupHasUnit(gv_swarmHost, UnitGroupLoopCurrent()) == true)) {
                UnitIssueOrder(UnitGroupLoopCurrent(), Order(AbilityCommand("ZergTrain", 11)), c_orderQueueReplace);
            }
            else {
                UnitIssueOrder(UnitGroupLoopCurrent(), Order(AbilityCommand("ZergTrain", 6)), c_orderQueueReplace);
            }
        }
        else {
        }
    }
    UnitGroupLoopEnd();

    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_UnitQueue3_Init () {
    gt_UnitQueue3 = TriggerCreate("gt_UnitQueue3_Func");
    TriggerAddEventTimePeriodic(gt_UnitQueue3, 10.0, c_timeGame);
}

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

    UnitGroupAdd(gv_hellbat, EventUnit());
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_Hellbat_Init () {
    gt_Hellbat = TriggerCreate("gt_Hellbat_Func");
    TriggerAddEventUnitAbility(gt_Hellbat, null, AbilityCommand("FactoryTrain", 6), c_unitAbilStageAll, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hellbat 2
//--------------------------------------------------------------------------------------------------
bool gt_Hellbat2_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    UnitGroupRemove(gv_hellbat, EventUnit());
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_Hellbat2_Init () {
    gt_Hellbat2 = TriggerCreate("gt_Hellbat2_Func");
    TriggerAddEventUnitAbility(gt_Hellbat2, null, AbilityCommand("FactoryTrain", 5), c_unitAbilStageAll, false);
    TriggerAddEventUnitAbility(gt_Hellbat2, null, AbilityCommand("FactoryTrain", 7), c_unitAbilStageAll, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Widow Mine
//--------------------------------------------------------------------------------------------------
bool gt_Widowmine_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    UnitGroupAdd(gv_widowmine, EventUnit());
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_Widowmine_Init () {
    gt_Widowmine = TriggerCreate("gt_Widowmine_Func");
    TriggerAddEventUnitAbility(gt_Widowmine, null, AbilityCommand("FactoryTrain", 7), c_unitAbilStageAll, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Widow Mine 2
//--------------------------------------------------------------------------------------------------
bool gt_Widowmine2_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    UnitGroupRemove(gv_widowmine, EventUnit());
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_Widowmine2_Init () {
    gt_Widowmine2 = TriggerCreate("gt_Widowmine2_Func");
    TriggerAddEventUnitAbility(gt_Widowmine2, null, AbilityCommand("FactoryTrain", 5), c_unitAbilStageAll, false);
    TriggerAddEventUnitAbility(gt_Widowmine2, null, AbilityCommand("FactoryTrain", 6), c_unitAbilStageAll, false);
}

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

    UnitGroupAdd(gv_loki, EventUnit());
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_Loki_Init () {
    gt_Loki = TriggerCreate("gt_Loki_Func");
    TriggerAddEventUnitAbility(gt_Loki, null, AbilityCommand("StarportTrain", 9), c_unitAbilStageAll, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Loki 2
//--------------------------------------------------------------------------------------------------
bool gt_Loki2_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    UnitGroupRemove(gv_loki, EventUnit());
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_Loki2_Init () {
    gt_Loki2 = TriggerCreate("gt_Loki2_Func");
    TriggerAddEventUnitAbility(gt_Loki2, null, AbilityCommand("StarportTrain", 3), c_unitAbilStageAll, false);
}

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

    UnitGroupAdd(gv_zeus, EventUnit());
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_Zeus_Init () {
    gt_Zeus = TriggerCreate("gt_Zeus_Func");
    TriggerAddEventUnitAbility(gt_Zeus, null, AbilityCommand("FactoryTrain", 13), c_unitAbilStageAll, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Zeus 2
//--------------------------------------------------------------------------------------------------
bool gt_Zeus2_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    UnitGroupRemove(gv_zeus, EventUnit());
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_Zeus2_Init () {
    gt_Zeus2 = TriggerCreate("gt_Zeus2_Func");
    TriggerAddEventUnitAbility(gt_Zeus2, null, AbilityCommand("FactoryTrain", 4), c_unitAbilStageAll, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Swarm Host
//--------------------------------------------------------------------------------------------------
bool gt_SwarmHost_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    UnitGroupAdd(gv_swarmHost, EventUnit());
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_SwarmHost_Init () {
    gt_SwarmHost = TriggerCreate("gt_SwarmHost_Func");
    TriggerAddEventUnitAbility(gt_SwarmHost, null, AbilityCommand("ZergTrain", 11), c_unitAbilStageAll, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Swarm Host 2
//--------------------------------------------------------------------------------------------------
bool gt_SwarmHost2_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    UnitGroupRemove(gv_swarmHost, EventUnit());
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_SwarmHost2_Init () {
    gt_SwarmHost2 = TriggerCreate("gt_SwarmHost2_Func");
    TriggerAddEventUnitAbility(gt_SwarmHost2, null, AbilityCommand("ZergTrain", 6), c_unitAbilStageAll, false);
}

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

    UnitGroupAdd(gv_raptorling, EventUnit());
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_Raptorling_Init () {
    gt_Raptorling = TriggerCreate("gt_Raptorling_Func");
    TriggerAddEventUnitAbility(gt_Raptorling, null, AbilityCommand("ZergTrain", 17), c_unitAbilStageAll, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Raptorling 2
//--------------------------------------------------------------------------------------------------
bool gt_Raptorling2_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    UnitGroupRemove(gv_raptorling, EventUnit());
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_Raptorling2_Init () {
    gt_Raptorling2 = TriggerCreate("gt_Raptorling2_Func");
    TriggerAddEventUnitAbility(gt_Raptorling2, null, AbilityCommand("ZergTrain", 0), c_unitAbilStageAll, false);
}

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

    UnitGroupAdd(gv_ghost, EventUnit());
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_Ghost_Init () {
    gt_Ghost = TriggerCreate("gt_Ghost_Func");
    TriggerAddEventUnitAbility(gt_Ghost, null, AbilityCommand("BarracksTrain", 6), c_unitAbilStageAll, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Ghost 2
//--------------------------------------------------------------------------------------------------
bool gt_Ghost2_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    UnitGroupRemove(gv_ghost, EventUnit());
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_Ghost2_Init () {
    gt_Ghost2 = TriggerCreate("gt_Ghost2_Func");
    TriggerAddEventUnitAbility(gt_Ghost2, null, AbilityCommand("BarracksTrain", 7), c_unitAbilStageAll, false);
}


//--------------------------------------------------------------------------------------------------
// Trigger: Siege Tank
//--------------------------------------------------------------------------------------------------
bool gt_SiegeTank_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    UnitGroupAdd(gv_siegeTank, EventUnit());
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_SiegeTank_Init () {
    gt_SiegeTank = TriggerCreate("gt_SiegeTank_Func");
    TriggerAddEventUnitAbility(gt_SiegeTank, null, AbilityCommand("FactoryTrain", 0), c_unitAbilStageAll, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Siege Tank 2
//--------------------------------------------------------------------------------------------------
bool gt_SiegeTank2_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    UnitGroupRemove(gv_siegeTank, EventUnit());
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_SiegeTank2_Init () {
    gt_SiegeTank2 = TriggerCreate("gt_SiegeTank_Func");
    TriggerAddEventUnitAbility(gt_SiegeTank2, null, AbilityCommand("FactoryTrain", 1), c_unitAbilStageAll, false);
}


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

    UnitGroupAdd(gv_queen, EventUnit());
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_Queen_Init () {
    gt_Queen = TriggerCreate("gt_Queen_Func");
    TriggerAddEventUnitAbility(gt_Queen, null, AbilityCommand("ZergTrain", 13), c_unitAbilStageAll, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Queen 2
//--------------------------------------------------------------------------------------------------
bool gt_Queen2_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    UnitGroupRemove(gv_queen, EventUnit());
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_Queen2_Init () {
    gt_Queen2 = TriggerCreate("gt_Queen2_Func");
    TriggerAddEventUnitAbility(gt_Queen2, null, AbilityCommand("ZergTrain", 4), c_unitAbilStageAll, false);
}

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

    UnitGroupAdd(gv_hybrid, EventUnit());
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_Hybrid_Init () {
    gt_Hybrid = TriggerCreate("gt_Hybrid_Func");
    TriggerAddEventUnitAbility(gt_Hybrid, null, AbilityCommand("ZergTrain", 19), c_unitAbilStageAll, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Hybrid 2
//--------------------------------------------------------------------------------------------------
bool gt_Hybrid2_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    UnitGroupRemove(gv_hybrid, EventUnit());
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_Hybrid2_Init () {
    gt_Hybrid2 = TriggerCreate("gt_Hybrid_Func");
    TriggerAddEventUnitAbility(gt_Hybrid2, null, AbilityCommand("ZergTrain", 5), c_unitAbilStageAll, false);
}

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

    UnitGroupAdd(gv_selendis, EventUnit());
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_Selendis_Init () {
    gt_Selendis = TriggerCreate("gt_Selendis_Func");
    TriggerAddEventUnitAbility(gt_Selendis, null, AbilityCommand("StargateTrain", 1), c_unitAbilStageAll, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Selendis 2
//--------------------------------------------------------------------------------------------------
bool gt_Selendis2_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    UnitGroupRemove(gv_selendis, EventUnit());
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_Selendis2_Init () {
    gt_Selendis2 = TriggerCreate("gt_Selendis_Func");
    TriggerAddEventUnitAbility(gt_Selendis2, null, AbilityCommand("StargateTrain", 2), c_unitAbilStageAll, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Double Zealot
//--------------------------------------------------------------------------------------------------
bool gt_DblZealot_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    UnitGroupAdd(gv_dblZealot, EventUnit());
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_DblZealot_Init () {
    gt_DblZealot = TriggerCreate("gt_DblZealot_Func");
    TriggerAddEventUnitAbility(gt_DblZealot, null, AbilityCommand("GatewayTrain", 6), c_unitAbilStageAll, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Double Zealot 2
//--------------------------------------------------------------------------------------------------
bool gt_DblZealot2_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    UnitGroupRemove(gv_dblZealot, EventUnit());
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_DblZealot2_Init () {
    gt_DblZealot2 = TriggerCreate("gt_DblZealot_Func");
    TriggerAddEventUnitAbility(gt_DblZealot2, null, AbilityCommand("GatewayTrain", 0), c_unitAbilStageAll, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger Initialization
//--------------------------------------------------------------------------------------------------
void InitTriggers () {
    gt_UnitQueue_Init();
    gt_UnitQueue2_Init();
    gt_UnitQueue3_Init();
    gt_Hellbat_Init();
    gt_Hellbat2_Init();
    gt_Widowmine_Init();
    gt_Widowmine2_Init();
    gt_Loki_Init();
    gt_Loki2_Init();
    gt_Zeus_Init();
    gt_Zeus2_Init();
    gt_SiegeTank_Init();
    gt_SiegeTank2_Init();
    gt_SwarmHost_Init();
    gt_SwarmHost2_Init();
    gt_Raptorling_Init();
    gt_Raptorling2_Init();
    gt_Ghost_Init();
    gt_Ghost2_Init();
    gt_Queen_Init();
    gt_Queen2_Init();
    gt_Hybrid_Init();
    gt_Hybrid2_Init();
    gt_Selendis_Init();
    gt_Selendis2_Init();
    gt_DblZealot_Init();
    gt_DblZealot2_Init();
}