Ticket #2206: correct_backtowork.2.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/GuiInterface.js

@@ -347 +347 @@
     {
         ret.unitAI = {
             "state": cmpUnitAI.GetCurrentState(),
-            "orders": cmpUnitAI.GetOrders(),
-            "lastWorkOrder": cmpUnitAI.GetLastWorkOrder(),
+            "orders": cmpUnitAI.GetWorkOrders(),
+            "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;
@@ -2806 +2806 @@
 
 UnitAI.prototype.BackToWork = function()
 {
-    if(this.lastWorkOrder)
+    if(this.workOrders.length)
     {
-        this.ReplaceOrder(this.lastWorkOrder.type, this.lastWorkOrder.data);
+        // Replace the current order queue
+        this.FlushOrders();
+        for each (var order in this.workOrders)
+            this.orderQueue.push(order);
+        
+        // Then, process the first order
+        
+        this.order = this.orderQueue[0];
+        var ret = UnitFsm.ProcessMessage(this,
+            {"type": "Order."+this.order.type, "data": this.order.data}
+        );
+
+        Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });
+
+        // If the order was rejected then immediately take it off
+        // and process the remaining queue
+        if (ret && ret.discardOrder)
+        {
+            this.FinishOrder();
+        }
         return true;
     }
     else
@@ -2831 +2850 @@
         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();
+    this.order = this.orderQueue[0];
+    
+    // Update the back-to-work queue
+    
     if(finishedOrder.type == "Gather" || finishedOrder.type == "Trade" || finishedOrder.type == "Repair")
-        this.lastWorkOrder = undefined;
-    
-    this.order = this.orderQueue[0];
+        this.workOrders.shift();
     // 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;
+    else if(finishedOrder.type == "ReturnResource" && (!this.order || this.order.type != "Gather"))
+        this.workOrders.shift();
+    
 
     if (this.orderQueue.length)
     {
@@ -2894 +2916 @@
     this.orderQueue.push(order);
     
     if(type == "Gather" || type == "Trade" || type == "Repair" || type == "ReturnResource")
-        this.lastWorkOrder = order;
+        this.workOrders.push(order);
 
     // If we didn't already have an order, then process this new one
     if (this.orderQueue.length == 1)
@@ -2950 +2972 @@
     }
 };
 
-UnitAI.prototype.ReplaceOrder = function(type, data)
+UnitAI.prototype.FlushOrders = function()
 {
     // Special cases of orders that shouldn't be replaced:
     // 1. Cheering - we're invulnerable, add order after we finish
@@ -2960 +2982 @@
     {
         var order = { "type": type, "data": data };
         var cheeringOrder = this.orderQueue.shift();
-        this.orderQueue = [ cheeringOrder, order ];
+        this.orderQueue = [cheeringOrder];
     }
     else if (this.IsPacking() && type != "CancelPack" && type != "CancelUnpack")
     {
         var order = { "type": type, "data": data };
         var packingOrder = this.orderQueue.shift();
-        this.orderQueue = [ packingOrder, order ];
+        this.orderQueue = [packingOrder];
     }
     else
-    {
         this.orderQueue = [];
-        this.PushOrder(type, data);
-    }
 };
 
+UnitAI.prototype.ReplaceOrder = function(type, data)
+{
+    this.FlushOrders();
+    if(type == "Gather" || type == "Trade" || type == "Repair" || type == "ReturnResource")
+        this.workOrders = [];
+    
+    this.PushOrder(type, data);
+};
+
 UnitAI.prototype.GetOrders = function()
 {
     return this.orderQueue.slice();
@@ -2998 +3026 @@
     return orders;
 };
 
-UnitAI.prototype.GetLastWorkOrder = function()
+UnitAI.prototype.HasWorkOrders = function()
 {
-    return this.lastWorkOrder;
+    return (this.workOrders.length > 0);
 };
 
-UnitAI.prototype.SetLastWorkOrder = function(order)
+UnitAI.prototype.GetWorkOrders = function()
 {
-    this.lastWorkOrder = order;
+    return this.workOrders;
 };
 
+UnitAI.prototype.SetWorkOrders = function(orders)
+{
+    this.workOrders = orders;
+};
+
 UnitAI.prototype.TimerHandler = function(data, lateness)
 {
     // Reset the timer