Ticket #2206: correct_backtowork.6.diff

binaries/data/mods/public/gui/session/input.js

@@ -2108 +2108 @@
     // Filter out all entities that can't go back to work.
     var workers = g_Selection.toList().filter(function(e) {
         var state = GetEntityState(e);
-        return (state && state.unitAI && state.unitAI.lastWorkOrder);
+        return (state && state.unitAI && state.unitAI.hasWorkOrders);
     });
     
     Engine.PostNetworkCommand({"type": "back-to-work", "workers": workers});

binaries/data/mods/public/gui/session/utility_functions.js

@@ -294 +294 @@
         });
     }
     
-    if (entState.unitAI && entState.unitAI.lastWorkOrder)
+    if (entState.unitAI && entState.unitAI.hasWorkOrders)
     {
         commands.push({
             "name": "back-to-work",

binaries/data/mods/public/simulation/components/Formation.js

@@ -115 +115 @@
     for each (var ent in ents)
     {
         var cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
+        cmpUnitAI.UpdateWorkOrders();
         cmpUnitAI.SetFormationController(INVALID_ENTITY);
     }
 

binaries/data/mods/public/simulation/components/GuiInterface.js

@@ -348 +348 @@
         ret.unitAI = {
             "state": cmpUnitAI.GetCurrentState(),
             "orders": cmpUnitAI.GetOrders(),
-            "lastWorkOrder": cmpUnitAI.GetLastWorkOrder(),
+            "hasWorkOrders": cmpUnitAI.HasWorkOrders(),
         };
         // Add some information needed for ungarrisoning
         if (cmpUnitAI.isGarrisoned && ret.player !== undefined)

binaries/data/mods/public/simulation/components/Promotion.js

@@ -78 +78 @@
     cmpPromotedUnitAI.Cheer();
     var orders = cmpCurrentUnitAI.GetOrders();
     cmpPromotedUnitAI.AddOrders(orders);
-    var lastWorkOrder = cmpCurrentUnitAI.GetLastWorkOrder();
-    cmpPromotedUnitAI.SetLastWorkOrder(lastWorkOrder);
+    var workOrders = cmpCurrentUnitAI.GetWorkOrders();
+    cmpPromotedUnitAI.SetWorkOrders(workOrders);
 
     Engine.BroadcastMessage(MT_EntityRenamed, { entity: this.entity, newentity: promotedUnitEntity });
 

binaries/data/mods/public/simulation/components/UnitAI.js

@@ -2526 +2526 @@
     this.lastFormationName = "";
     this.finishedOrder = false; // used to find if all formation members finished the order
     
-    // To go back to work later
-    this.lastWorkOrder = undefined;
+    // Queue of remembered works
+    this.workOrders = [];
 
     // For preventing increased action rate due to Stop orders or target death.
     this.lastAttacked = undefined;
@@ -2804 +2804 @@
     Engine.PostMessage(this.entity, MT_UnitAIStateChanged, { "to": state });
 };
 
-UnitAI.prototype.BackToWork = function()
-{
-    if(this.lastWorkOrder)
-    {
-        this.ReplaceOrder(this.lastWorkOrder.type, this.lastWorkOrder.data);
-        return true;
-    }
-    else
-        return false;
-};
-
 /**
  * Call when the current order has been completed (or failed).
  * Removes the current order from the queue, and processes the
@@ -2831 +2820 @@
         error("FinishOrder called for entity " + this.entity + " (" + template + ") when order queue is empty\n" + stack);
     }
 
-    // Remove the order from the queue, then forget it if it was a work to avoid trying to go back to it later.
+    // Remove the order from the queue
     var finishedOrder = this.orderQueue.shift();
-    if(finishedOrder.type == "Gather" || finishedOrder.type == "Trade" || finishedOrder.type == "Repair")
-        this.lastWorkOrder = undefined;
-    
     this.order = this.orderQueue[0];
-    // If the worker was returning a resource, we shall 
-    //  -> (if the worker is gathering) keep remembering the "Gather" order which is this.order
-    //  -> (if the worker was directly ordered to return a resource) forget the "ReturnResource" order which is finished
-    if(finishedOrder.type == "ReturnResource" && (!this.order || this.order.type != "Gather"))
-        this.lastWorkOrder = undefined;
 
     if (this.orderQueue.length)
     {
@@ -2892 +2873 @@
 {
     var order = { "type": type, "data": data };
     this.orderQueue.push(order);
-    
-    if(type == "Gather" || type == "Trade" || type == "Repair" || type == "ReturnResource")
-        this.lastWorkOrder = order;
 
     // If we didn't already have an order, then process this new one
     if (this.orderQueue.length == 1)
@@ -2952 +2930 @@
 
 UnitAI.prototype.ReplaceOrder = function(type, data)
 {
+    // Keep the previous orders if needed
+    if (data && data.force)
+    {
+        // Handle formations
+        if (this.IsFormationController())
+        {
+            var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
+            cmpFormation.CallMemberFunction("UpdateWorkOrders", [type]);
+        }
+        else
+            this.UpdateWorkOrders(type);
+    }
+
     // Special cases of orders that shouldn't be replaced:
     // 1. Cheering - we're invulnerable, add order after we finish
     // 2. Packing/unpacking - we're immobile, add order after we finish (unless it's cancel)
@@ -2998 +2989 @@
     return orders;
 };
 
-UnitAI.prototype.GetLastWorkOrder = function()
+UnitAI.prototype.UpdateWorkOrders = function(type)
 {
-    return this.lastWorkOrder;
+    var isWorkType = function(type){
+        return (type == "Gather" || type == "Trade" || type == "Repair" || type == "ReturnResource");
+    };
+    
+    if (isWorkType(type))
+        this.workOrders = [];
+    else if (!this.workOrders.length)
+    {
+        // First if the unit is in a formation, get its workOrders from it
+        if (this.IsFormationMember())
+        {
+            var cmpUnitAI = Engine.QueryInterface(this.formationController, IID_UnitAI);
+            for (var i = 0; i < cmpUnitAI.orderQueue.length; ++i)
+            {
+                var ordertype = cmpUnitAI.orderQueue[i].type;
+                if (isWorkType(ordertype))
+                {
+                    this.workOrders = cmpUnitAI.orderQueue.slice(i);
+                    break;
+                }
+            }
+        }
+
+        // If nothing found, take the unit orders
+        if (!this.workOrders.length)
+        {
+            for (var i = 0; i < this.orderQueue.length; ++i)
+            {
+                var ordertype = this.orderQueue[i].type;
+                if (isWorkType(ordertype))
+                {
+                    this.workOrders = this.orderQueue.slice(i);
+                    break;
+                }
+            }
+        }
+    }
 };
 
-UnitAI.prototype.SetLastWorkOrder = function(order)
+UnitAI.prototype.BackToWork = function()
+{   
+    if(this.workOrders.length > 0)
+    {
+        // Clear the order queue considering special orders not to avoid
+        if (this.order && this.order.type == "Cheering")
+        {
+            var cheeringOrder = this.orderQueue.shift();
+            this.orderQueue = [ cheeringOrder ];
+        }
+        else
+            this.orderQueue = [];
+        
+        this.AddOrders(this.workOrders);
+        
+        // And if the unit is in a formation, remove it from the formation
+        if (this.IsFormationMember())
+            Engine.QueryInterface(this.formationController, IID_Formation).RemoveMembers([this.entity]);
+        
+        this.workOrders = [];
+        return true;
+    }
+    else
+        return false;
+};
+
+UnitAI.prototype.HasWorkOrders = function()
 {
-    this.lastWorkOrder = order;
+    return (this.workOrders.length > 0);
 };
 
+UnitAI.prototype.GetWorkOrders = function()
+{
+    return this.workOrders;
+};
+
+UnitAI.prototype.SetWorkOrders = function(orders)
+{
+    this.workOrders = orders;
+};
+
 UnitAI.prototype.TimerHandler = function(data, lateness)
 {
     // Reset the timer

binaries/data/mods/public/simulation/helpers/Commands.js

@@ -170 +170 @@
             cmpUnitAI.ReturnResource(cmd.target, cmd.queued);
         });
         break;
+        
+    case "back-to-work":        
+        var entities = FilterEntityList(cmd.workers, player, controlAllUnits);
+        for each (var ent in entities)
+        {
+            var cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
+            if(!cmpUnitAI || !cmpUnitAI.BackToWork())
+                notifyBackToWorkFailure(player);
+        }
+        break;
 
     case "train":
         // Check entity limits
@@ -390 +400 @@
                 notifyUnloadFailure(player, garrisonHolder)
         }
         break;
-        
-    case "back-to-work":
-        var entities = FilterEntityList(cmd.workers, player, controlAllUnits);
-        for each (var worker in entities)
-        {
-            var cmpUnitAI = Engine.QueryInterface(worker, IID_UnitAI);
-            if (!cmpUnitAI || !cmpUnitAI.BackToWork())
-                notifyBackToWorkFailure(player, worker)
-        }
-        break;
 
     case "formation":
         GetFormationUnitAIs(entities, player, cmd.name).forEach(function(cmpUnitAI) {
@@ -530 +530 @@
 /**
  * Sends a GUI notification about worker(s) that failed to go back to work.
  */
-function notifyBackToWorkFailure(player, worker)
+function notifyBackToWorkFailure(player)
 {
     var cmpPlayer = QueryPlayerIDInterface(player, IID_Player);
     var notification = {"player": cmpPlayer.GetPlayerID(), "message": "Some unit(s) can't go back to work" };