• 0

    posted a message on Unit Orders Trigger

    I seem to be having a hard time finding everything for that trigger Imperial. I am new to the editor. Can you give me an example of trigger the one you said would fetch nearest waypoint?

    Posted in: Triggers
  • 0

    posted a message on Unit Orders Trigger

    Hi, I am doing a tug-of-war type map, and have a mothership (planning on switching to arbiter soon) with recall. I have units orderered upon building to go to their appropriate lanes toward enemy base already. But when units are recalled to a location, they lose their orders. I want them to retain their orders after recall, and not have to be ordered to a new point depending on where the unit currently is at. I don't know if this is possible. If not, can someone at least tell me how I can make recalled units only be ordered to auto-attack a new point? Is it some sort of effect?

    Posted in: Triggers
  • 0

    posted a message on Scripting Auto-Unit Queues

    Fixed everything by myself, thread can be closed.

    Posted in: Galaxy Scripting
  • 0

    posted a message on Scripting Auto-Unit Queues

    Well, I found the wait command fix the execution hang. But now whenever someone ques up hellion it will cause the game to make a never-ending series of ques on hellion not letting anyone switch units at that point. Why is that? This is what I changed from the last time.

        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);
            }
            if ((UnitGroupHasUnit(gv_hellbat, EventUnit()) == false)) {
                while ((UnitGroupHasUnit(gv_widowmine, EventUnit()) == false)) {
                    UnitIssueOrder(EventUnit(), Order(AbilityCommand("FactoryTrain", 5)), c_orderQueueReplace);
                    Wait(0.2, c_timeGame);
                }
            }
            else {
            }
        }
        else { 
    and
        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);
                }
                if ((UnitGroupHasUnit(gv_hellbat, UnitGroupLoopCurrent()) == false)) {
                    while ((UnitGroupHasUnit(gv_widowmine, UnitGroupLoopCurrent()) == false)) {
                        UnitIssueOrder(UnitGroupLoopCurrent(), Order(AbilityCommand("FactoryTrain", 5)), c_orderQueueReplace);
                        Wait(0.2, c_timeGame);
                    }           
                }
                else {
                }
            }
            else {
            }
        }
        UnitGroupLoopEnd();
    

    Posted in: Galaxy Scripting
  • 0

    posted a message on Scripting Auto-Unit Queues

    Well, I figured out that I need to add a while or some loop to get both of those conditions to work for hellbat. But now it hangs for a minute or two with the messages "00:01:00.00 Gala: Script runtime error: Execution took too long Near line 4509 in gt_UnitQueue_Func() in MapScript.galaxy 00:01:00.00 Scri: Trigger Error in 'gt_UnitQueue_Func': Execution took too long" before queuing 5x hellions. Also, I found out that the carrier/selendis building is queuing only selendis, and I have verified that the ability commands are correct. Don't know what is wrong here - I am new to .galaxy editing; or triggering at all since SC1 and only have done code splicing copy/paste over the years for various other games.

    Here is the new code that queues hellion after most recent attempts to fix it.

    //--------------------------------------------------------------------------------------------------
    // 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);
            }
            if ((UnitGroupHasUnit(gv_hellbat, EventUnit()) == false)) {
                while ((UnitGroupHasUnit(gv_widowmine, EventUnit()) == false)) {
                    UnitIssueOrder(EventUnit(), Order(AbilityCommand("FactoryTrain", 5)), c_orderQueueReplace);
                }
            }
            else {
            }
        }
        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);
                }
                if ((UnitGroupHasUnit(gv_hellbat, UnitGroupLoopCurrent()) == false)) {
                    while ((UnitGroupHasUnit(gv_widowmine, UnitGroupLoopCurrent()) == false)) {
                        UnitIssueOrder(UnitGroupLoopCurrent(), Order(AbilityCommand("FactoryTrain", 5)), c_orderQueueReplace);
                    }
                }
                else {
                }
            }
            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();
    }
    
    Posted in: Galaxy Scripting
  • 0

    posted a message on Scripting Auto-Unit Queues

    Ok this is a Nexus Wars variant I am doing, and I am wanting to spawn different units from the same building that you can select from. I have added these scripts for unit groups and queues. The zealot doesn't auto-que after each new unit, but the upgraded one does, some are queing the unit and the other one after. What am I missing here? Here is all the pertinent codes for any of the unit/queues for any of the related variables in a text file.

    Posted in: Galaxy Scripting
  • 0

    posted a message on Zeratul Void Prison

    I wasn't sure what forum thread to put this in, but I was wondering if for a NW map how I can make zeratul decloak for 9 seconds upon using void prison?

    Posted in: Miscellaneous Development
  • To post a comment, please or register a new account.